[API Proposal] Enhance support for overriding default(T) where T: class

[Sophisticated-IS]

Motivation
Now default(T) is completely unusable for reference types because it always compiles to null. And you anyway have to use static fields to have default value different from null.
If we could override this behavior and encapsulate "Default value" of Type in class it would greatly increase default(T) usability.

Proposing Behavior:
IF class not implements IDefaultProvider than compile default(T) to null
IF implements then replace with method call to Default property

Example:

public class MyCustomType : IDefaultProvider<MyCustomType>
{
    public int X { get; set; }
    public int Y { get; set; }
    public required NestedCustomType Nested { get; set; }

    
    public static MyCustomType? Default { get; } = new MyCustomType
    {
        X = 1,
        Y = 1,
        Nested = new()
        {
            Z=0,
            K= "empty"
        }
    };
}

public class NestedCustomType
{
    public int Z { get; set; }
    public string K { get; set; }
}


public interface IDefaultProvider<TSelf> where TSelf : class
{
    static abstract TSelf? Default { get; }
}

[hez2010]

Many codes rely on the fact which default(T) is null for classes.
You can create your own interface IHasDefaultValue and implement it on your type:

interface IHasDefaultValue<T>
{
    virtual static T? GetDefault() => null;
}

class Foo : IHasDefaultValue<Foo>
{
    static Foo? IHasDefaultValue<Foo>.GetDefault() => new Foo();
}

T? DefaultOf<T>() where T : IHasDefaultValue<T> => T.GetDefault();

var v = DefaultOf<Foo>();

[huoyaoyuan]

Now default(T) is completely unusable for reference types because it always compiles to null.

The same issue also applies to value types, especially when the type is a wrapper of some reference type.

Ideally, we should track default of value type in the same way of nullable reference type. This is the purpose of the non-defaultable struct proposal.