Support "Functor-like" code_typed invocation (#57911)

This lets you easily inspect IR associated with "Functor-like" methods:
```julia
julia> (f::Foo)(offset::Float64) = f.x + f.y + offset
julia> code_typed((Foo, Float64))
1-element Vector{Any}:
 CodeInfo(
1 ─ %1 = Base.getfield(f, :x)::Int64
│   %2 = Base.getfield(f, :y)::Int64
│   %3 = Base.add_int(%1, %2)::Int64
│   %4 = Base.sitofp(Float64, %3)::Float64
│   %5 = Base.add_float(%4, offset)::Float64
└──      return %5
) => Float64
```

This is just a small convenience over `code_typed_by_type`, but I'm in
support of it (even though it technically changes the meaning of, e.g.,
`code_typed((1, 2))` which without this PR inspects
`(::Tuple{Int,Int})(::Vararg{Any})`

We should probably update all of our reflection machinery (`code_llvm`,
`code_lowered`, `methodinstance`, etc.) to support this "non-arg0" style
as well, but I wanted to open this first to make sure folks like it.

Author: topolarity

base/reflection.jl

@@ -211,8 +211,31 @@ julia> code_typed(+, (Float64, Float64))
 1 ─ %1 = Base.add_float(x, y)::Float64
 └──      return %1
 ) => Float64
+
+julia> code_typed((typeof(-), Float64, Float64))
+1-element Vector{Any}:
+ CodeInfo(
+1 ─ %1 = Base.sub_float(x, y)::Float64
+└──      return %1
+) => Float64
+
+julia> code_typed((Type{Int}, UInt8))
+1-element Vector{Any}:
+ CodeInfo(
+1 ─ %1 = Core.zext_int(Core.Int64, x)::Int64
+└──      return %1
+) => Int64
+
+julia> code_typed((Returns{Int64},))
+1-element Vector{Any}:
+ CodeInfo(
+1 ─ %1 =   builtin Base.getfield(obj, :value)::Int64
+└──      return %1
+) => Int64
 ```
 """
+function code_typed end
+
 function code_typed(@nospecialize(f), @nospecialize(types=default_tt(f)); kwargs...)
     if isa(f, Core.OpaqueClosure)
         return code_typed_opaque_closure(f, types; kwargs...)
@@ -221,6 +244,12 @@ function code_typed(@nospecialize(f), @nospecialize(types=default_tt(f)); kwargs
     return code_typed_by_type(tt; kwargs...)
 end
 
+# support 'functor'-like queries, such as `(::Foo)(::Int, ::Int)` via `code_typed((Foo, Int, Int))`
+function code_typed(@nospecialize(argtypes::Union{Tuple,Type{<:Tuple}}); kwargs...)
+    tt = to_tuple_type(argtypes)
+    return code_typed_by_type(tt; kwargs...)
+end
+
 # returns argument tuple type which is supposed to be used for `code_typed` and its family;
 # if there is a single method this functions returns the method argument signature,
 # otherwise returns `Tuple` that doesn't match with any signature