avoid excessive renaming in subtype of intersection result

[JeffBezanson]

In computing typeintersect(A, B) <: A, the intersection result would tend to share typevars with A, causing subtyping to do lots of renaming. Luckily it turns out we can avoid that just by doing more renaming in the intersection result beforehand.

fixes #39505, fixes #39394

[JeffBezanson]

Example query:

using LinearAlgebra,StaticArrays

t1 = Tuple{typeof(vcat), Union{Adjoint{T, s6} where s6<:Union{StaticVector{s1, T} where s1, StaticMatrix{s4, s5, T} where {s4, s5}}, Diagonal{T, s13} where s13<:(StaticVector{s14, T} where s14), Hermitian{T, s10} where s10<:(StaticMatrix{s11, s12, T} where {s11, s12}), LowerTriangular{T, s18} where s18<:(StaticMatrix{s19, s20, T} where {s19, s20}), Symmetric{T, s7} where s7<:(StaticMatrix{s8, s9, T} where {s8, s9}), Transpose{T, s1} where s1<:Union{StaticVector{s1, T} where s1, StaticMatrix{s4, s5, T} where {s4, s5}}, UnitLowerTriangular{T, s24} where s24<:(StaticMatrix{s25, s26, T} where {s25, s26}), UnitUpperTriangular{T, s21} where s21<:(StaticMatrix{s22, s23, T} where {s22, s23}), UpperTriangular{T, s15} where s15<:(StaticMatrix{s16, s17, T} where {s16, s17}), StaticVector{s26, T} where s26, StaticMatrix{s5, s4, T} where {s5, s4}} where T, Union{Adjoint{T, s6} where s6<:Union{StaticVector{s1, T} where s1, StaticMatrix{s4, s5, T} where {s4, s5}}, Diagonal{T, s13} where s13<:(StaticVector{s14, T} where s14), Hermitian{T, s10} where s10<:(StaticMatrix{s11, s12, T} where {s11, s12}), LowerTriangular{T, s18} where s18<:(StaticMatrix{s19, s20, T} where {s19, s20}), Symmetric{T, s7} where s7<:(StaticMatrix{s8, s9, T} where {s8, s9}), Transpose{T, s1} where s1<:Union{StaticVector{s1, T} where s1, StaticMatrix{s4, s5, T} where {s4, s5}}, UnitLowerTriangular{T, s24} where s24<:(StaticMatrix{s25, s26, T} where {s25, s26}), UnitUpperTriangular{T, s21} where s21<:(StaticMatrix{s22, s23, T} where {s22, s23}), UpperTriangular{T, s15} where s15<:(StaticMatrix{s16, s17, T} where {s16, s17}), StaticVector{s26, T} where s26, StaticMatrix{s5, s4, T} where {s5, s4}} where T, Vararg{Union{Adjoint{T, s6} where s6<:Union{StaticVector{s1, T} where s1, StaticMatrix{s4, s5, T} where {s4, s5}}, Diagonal{T, s13} where s13<:(StaticVector{s14, T} where s14), Hermitian{T, s10} where s10<:(StaticMatrix{s11, s12, T} where {s11, s12}), LowerTriangular{T, s18} where s18<:(StaticMatrix{s19, s20, T} where {s19, s20}), Symmetric{T, s7} where s7<:(StaticMatrix{s8, s9, T} where {s8, s9}), Transpose{T, s1} where s1<:Union{StaticVector{s1, T} where s1, StaticMatrix{s4, s5, T} where {s4, s5}}, UnitLowerTriangular{T, s24} where s24<:(StaticMatrix{s25, s26, T} where {s25, s26}), UnitUpperTriangular{T, s21} where s21<:(StaticMatrix{s22, s23, T} where {s22, s23}), UpperTriangular{T, s15} where s15<:(StaticMatrix{s16, s17, T} where {s16, s17}), StaticVector{s26, T} where s26, StaticMatrix{s5, s4, T} where {s5, s4}} where T, N} where N}

t2 = Tuple{typeof(Base.vcat), Vararg{Union{Array{T, 1} where T, Array{T, 2} where T, LinearAlgebra.AbstractTriangular{T, A} where A<:(Array{T, 2} where T) where T, LinearAlgebra.Adjoint{var"#s831", var"#s830"} where var"#s830"<:(Array{T, 1} where T) where var"#s831", LinearAlgebra.Hermitian{T, A} where A<:(Array{T, 2} where T) where T, LinearAlgebra.Symmetric{T, A} where A<:(Array{T, 2} where T) where T, LinearAlgebra.Transpose{var"#s829", var"#s828"} where var"#s828"<:(Array{T, 1} where T) where var"#s829"}}}

isect = typeintersect(t1, t2)

isect <: t1  # 40x faster

[JeffBezanson]

Ok, this got a bit interesting. To fix one test failure, I needed to make switch_union_tuple a bit more accurate by merging type variables when possible (since this change produces different typevars where we used to return the same one). Then there was this strange behavior in 1.6 and prior versions:

julia> U = Vector{Vector{T}} where T;

julia> S = Tuple{U, U};

julia> T = Union{Tuple{T, Vector{T}}, Tuple{T, Vector{Int64}}} where T;

julia> typeintersect(T,S)
Union{}

julia> typeintersect(T, Tuple{Vector{Vector{T}} where T, Vector{Vector{T}} where T})
Tuple{Array{Vector{T}, 1} where T, Array{Vector{T}, 1}} where T

IOW, when the unionall variables inside S are identical, we accidentally get Union{}, which I think is right, but obviously should not depend on the identities of the variables. Now we give a consistent but more conservative answer.