HTTP constants being static readonly with no const option

[driuba]

I got tired of redefining the same HTTP constants in every single project I work on, because sometimes I just need a compile time constant (switch ... case ..., attributes, default method argument value). And I want to ask: why for the love of God constants were completely removed?

I've read the discussion on #9514 when a change was made to improve string comparison performance for HeaderNames and I've seen multiple people suggesting the obvious solution of using backing const field for static readonly fields.

Like what was preventing a similar implementation?

public static class HttpMethods
{
    public static readonly string Connect = Constants.Connect;
    public static readonly string Delete = Constants.Delete;
    public static readonly string Get = Constants.Get;
    public static readonly string Head = Constants.Head;
    public static readonly string Options = Constants.Options;
    public static readonly string Patch = Constants.Patch;
    public static readonly string Post = Constants.Post;
    public static readonly string Put = Constants.Put;
    public static readonly string Trace = Constants.Trace;

    public static class Constants
    {
        public const string Connect = "CONNECT";
        public const string Delete = "DELETE";
        public const string Get = "GET";
        public const string Head = "HEAD";
        public const string Options = "OPTIONS";
        public const string Patch = "PATCH";
        public const string Post = "POST";
        public const string Put = "PUT";
        public const string Trace = "TRACE";
    }
}

Why was this the preferred solution?

public static class HttpMethods
{
    // We are intentionally using 'static readonly' here instead of 'const'.
    // 'const' values would be embedded into each assembly that used them
    // and each consuming assembly would have a different 'string' instance.
    // Using .'static readonly' means that all consumers get these exact same
    // 'string' instance, which means the 'ReferenceEquals' checks below work
    // and allow us to optimize comparisons when these constants are used.

    // Please do NOT change these to 'const'
    /// <summary>
    /// HTTP "CONNECT" method.
    /// </summary>
    public static readonly string Connect = "CONNECT";
    /// <summary>
    /// HTTP "DELETE" method.
    /// </summary>
    public static readonly string Delete = "DELETE";
    /// <summary>
    /// HTTP "GET" method.
    /// </summary>
    public static readonly string Get = "GET";
    /// <summary>
    /// HTTP "HEAD" method.
    /// </summary>
    public static readonly string Head = "HEAD";
    /// <summary>
    /// HTTP "OPTIONS" method.
    /// </summary>
    public static readonly string Options = "OPTIONS";
    /// <summary>
    /// HTTP "PATCH" method.
    /// </summary>
    public static readonly string Patch = "PATCH";
    /// <summary>
    /// HTTP "POST" method.
    /// </summary>
    public static readonly string Post = "POST";
    /// <summary>
    /// HTTP "PUT" method.
    /// </summary>
    public static readonly string Put = "PUT";
    /// <summary>
    /// HTTP "TRACE" method.
    /// </summary>
    public static readonly string Trace = "TRACE";
}

After reading the discussion this seems so obvious and it seems to get best of both worlds: ability to use ReferenceEquals optimization with an option to have a compile time constant when needed. And the solution isn't event complicated.

Can anybody elaborate and explain to me what am I missing here? What are your thoughts on this?