gf: add support for invalidating invoke edges

[vtjnash]

Apparently we never actually implemented support for invalidation detection on invoke edges, and furthermore, it had erased part of the support for regular edges.

Generalize our code for detecting replacement of a method, to be used when computing replacement of an invoke edge.

Fix #48802

(if you squint, you will notice this PR is mostly about merging several code paths, and not actually quite as involved as it looks at first glance)

[timholy]

Thanks for tackling this. My only comment of consequence is that this would benefit from a test.

[timholy]

I wonder if morespec -> morespecific would be worth the extra Chars. Also, what about morespecifc_true/morespecific_false/morespecific_unknown?

[vtjnash]

I don't really want to deal with the code churn to rename an existing flag now. It is only used locally anyways.

[timholy]

I don't doubt this is true, but is there a simple example of how this could happen?

[vtjnash]

Simple? Probably not haha. The current canonical example in one argument looks something like this, where 1 and 2 are ambiguous, and 3 is ambiguous with 1+2 but neither 1 nor 2:

module Ambig8
# complex / unsorted(-able) ambiguities
f(::Union{typeof(pi), Integer}) =  1
f(::Union{AbstractIrrational, Int}) =  2
f(::Signed) = 3
end

This is only ambiguous over f(::Int), but it causes the sort order for f(::Signed) to be somewhat ambiguous too (since f(::Int) is one subtype of that). This is a simple case though, since it is mostly just subtyping relations, and subtyping is transitive.

A more complicated case (just invented here, never seen before!), might look like the below. Note how no 2 methods are ambiguous (there always exists a parameter of the union that distinguishes them), but that among the 3 of them, there exists a circularity of specificity such that none is uniformly dominant for f(::Int) over the other 2.

julia> f(::Union{Int, UInt, AbstractIrrational}) = 1
f (generic function with 1 method)

julia> f(::Union{Int, Float64, Unsigned}) = 2
f (generic function with 2 methods)

julia> f(::Union{Int, typeof(pi), AbstractFloat}) = 3
f (generic function with 3 methods)

julia> Base.isambiguous(methods(f)[1], methods(f)[2])
false

julia> Base.isambiguous(methods(f)[1], methods(f)[3])
false

julia> Base.isambiguous(methods(f)[2], methods(f)[3])
false

julia> f(1)
ERROR: MethodError: f(::Int64) is ambiguous.

Candidates:
  f(::Union{Float64, Int64, Unsigned})
    @ Main REPL[2]:1
  f(::Union{Irrational{:π}, Int64, AbstractFloat})
    @ Main REPL[3]:1
  f(::Union{Int64, UInt64, AbstractIrrational})
    @ Main REPL[1]:1

Possible fix, define
  f(::Int64)

Stacktrace:
 [1] top-level scope
   @ REPL[7]:1

[timholy]

Genius. And sad that it's so complicated (but no one said subtyping was easy).