inlining: make union splitting account for uncovered call

[aviatesk]

#44421 changed the union-splitting to skip generating unnecessary fallback dynamic dispatch call when there is any fully covered call.
But it turned out that this is only valid when there is any fully covered call in matches for all signatures that inference split, and it is invalid if there is any union split signature against which any uncovered call is found.

Consider the following example:

# case 1
    # def
    nosplit(::Any) = [...]
    nosplit(::Int) = [...]
    # call
    nosplit(a::Any)
        split1: a::Any ┬ nosplit(a::Int)
                       └ nosplit(a::Any) # fully covers split1

# case 2
    # def
    convert(::Type{T}, ::T) = T
    # call
    convert(::Type{Union{Bool,Tuple{Int,String}}}, a::Union{Bool,Tuple{Int,Any}})
        split1: a::Bool           ─ convert(::Type{Bool}, ::Bool)                           # fully covers split1
        split2: a::Tuple{Int,Any} ─ convert(::Type{Tuple{Int,String}}, ::Tuple{Int,String}) # NOT fully covers split2

#44421 allows us to optimize the the first case, but handles the second case wrongly. This commit fixes it up while still optimizing the first case.

fix #48397.

[aviatesk]

@nanosoldier runbenchmarks("inference", vs=":master")

[nanosoldier]

Your benchmark job has completed - no performance regressions were detected. A full report can be found here.

[vtjnash]

You can make these tests more reliable by looking at the return value here

Suggested change

	@test_throws MethodError let
	Base.Experimental.@force_compile
	f48397(g48397)
	end
	let err = (@test_throws MethodError let
	Base.Experimental.@force_compile
	f48397(g48397)
	end).value
	@test err.f === f48397 && err.args === (g48397,)
	end