Proposal: Duck typing invocable

[2A5F]

Make anything with an Invoke method invocable

struct Foo
{
    void Invoke() {}
    int Invoke(int a, int b) => a + b;
    void Invoke<T>(T a) {}
}

var a = new Foo();
a();
var b = a(123, 456);
a("asd");

This solves type infer issues for extensions.
The extensions must be compatible, but library authors can create wrappers to avoid type infer issues.

struct Foo<T>;

public static class Extensions
{
    extension<T>(ref Foo<T> foo)
    {
        public FooMethodWrapper<T> Method => new(ref foo);
    }
}

public ref struct FooMethodWrapper<T>(ref Foo<T> a)
{
    ref Foo<T> a = ref a;

    void Invoke<U>() {}
}

// then

var foo = new Foo<int>();
foo.Method<float>();

// compile to

foo.Method.Invoke<float>();

---

#8696

[jnm2]

See: #95, #7084