Allow unions of same-type containers for certain container methods

[HertzDevil]

The following fails to compile, even though it should have a well-defined result:

def foo
  true ? [1] : ['a']
end

foo + foo # Error: no overload matches 'Array(Float64)#+' with type (Array(Float64) | Array(Int32))

This happens because Array(T)#+(other : Array(U)) forall U ensures only that self is never a union of arrays, but other in general could be one; thus, following the discussion from #8973, it is correct to issue a compiler error here (although U shouldn't even be substitutable in the first place). The solution is to remove the unnecessary free var in the other's restriction, which works for most methods affected by this PR. They are:

• Array#&
• Array#|
• Array#+
• Array#-
• Array#product (Move Array#product to Indexable#cartesian_product #10013 does not have the same free var anymore)
• Deque#+
• Hash#merge (both block and non-block overloads)
• Set#|
• Set#+
• Set#^ (relies on Enumerable#first_internal copied from Make Array#transpose, Enumerable#reject, Enumerable#to_h work with tuples #10445)

In the example above, this makes typeof(foo + foo) always equal to Array(Int32 | Char), instead of Array(Int32 | Char) | Array(Int32) | Array(Char). However this trick doesn't work with Tuple#+ and NamedTuple#merge, because even though these types have built-in covariance, the types with different arities / names still cannot be merged. Those two methods are fixed instead by dispatching over the other argument's type. In other words:

def foo
  true ? {1} : {'a'}
end

typeof(foo + foo) # => Tuple(Char | Int32, Char | Int32)

def bar
  true ? {1} : {'a', 'a'}
end

typeof(bar + bar) # => (Tuple(Char | Int32, Char, Char | Int32)
                  #   | Tuple(Char, Char, Char, Char)
                  #   | Tuple(Int32, Int32))

Note that #10429 disallows unions inside splats, so a + b supports more types than {*a, *b} (it already does since a can already be a union of Tuples).