Support splat expansions inside tuple and array literals

[HertzDevil]

Implements #3718. Does not implement double splats and #3718 (comment) (#to_array_splat). The codegen portion for Tuple splats is copied directly from #10193's head (with the codegen optimization).

Tuple and array literals have slightly different requirements on the splatted value's interface:

# `exp` must be a `Tuple` instance, it cannot be a union of `Tuple`s (of different arities)
{*exp}

# `exp` must respond to `#each(& : _ -> _)`
[*exp]
[*exp] of T
T{*exp}
T(U, ...){*exp}

Very few array-like types implement #each but do not include Enumerable, so the requirement on Enumerable shouldn't be a pressing issue. (CSV and Regex::MatchData are notable exceptions in the standard library.)

[HertzDevil]

Instead of __crystal_first there is now Enumerable.element_type, other kinds of literal expansions refer to class methods in the prelude so this shouldn't be a problem. It might replace the first_internal helper I added in some other PRs too.

[Sija]

Suggested change

	# NOTE: there should never be a need to call this method outside the standard library.
	# WARNING: there should never be a need to call this method outside the standard library.

[straight-shoota]

I don't think this should be a warning.
We could consider making this method nodoc, though. It's only internal API.

[HertzDevil]

The PR currently doesn't allow non-Enumerable splats inside Arrays because of Array#concat(other : Enumerable)'s type restriction (array literals expand to concat, not the more verbose each loop). Should we remove that type restriction?

[straight-shoota]

I suppose this restriction is not really necessary. However, what type would implement a compatible #each interface an not include Enumerable? Practically, I don't see much impact.

[HertzDevil]

CSV, Enum (flags enums only), LLVM::FunctionCollection, and YAML::Nodes::Mapping.

For comparison Set#concat does not have the same restriction, so it is possible to write:

@[Flags]
enum Foo
  X
  Y
  Z
end

set = Set(Foo).new
set.concat(Foo::All) # => Set{X, Y, Z}

[asterite]

Great use of this variant of any?! It actually reads really nice too :-)

[asterite]

I love this new feature! ❤️