¿Por qué C++ no convierte implícitamente el argumento del lado izquierdo a una sobrecarga de operador no amiga?

Considere lo siguiente: (Enlace a Compiler Explorer: aquí)

class A {
private:
    int val;

public:
    inline A() : val(0) {}
    inline A(int x) : val(x) {}
    //inline bool operator<(const A& other) const {return val < other.val;}
    friend inline bool operator<(const A& lhs, const A& rhs) {return lhs.val < rhs.val;}
};

int main(int, char**) {
    A a;
    //return 2 < a;
    return a < 2;
}

• Esto compila.
• Si se intercambia la declaración de retorno por la línea comentada, también compila.
• Si se intercambia la línea del operador < por la línea comentada, también compila.
• Si se intercambia ambas líneas anteriores por sus versiones comentadas al mismo tiempo, ya no compila:

error: no match for 'operator<' (operand types are 'int' and 'A')

Claramente, C++ es capaz de realizar una conversión implícita (de int a const A&) en ambos lados del operador < cuando se utiliza la versión friend del operador. Habría esperado que la versión no friend funcionara de la misma manera, pero parece que un valor no puede convertirse implícitamente cuando necesita convertirse en el objeto “this” en una sobrecarga de operador.

Supongo que si en lugar de una función de operador definiera una función no operadora regular, tampoco esperaría que (2).func(a) realice una conversión implícita, por lo que viéndolo de esta manera tiene sentido, pero aún así parece extraño que la conversión no se realice en el caso de un operador.

¿C++ deshabilita esta forma de conversión implícita porque la considera similar a una llamada a función miembro? ¿O hay una razón diferente específica para los operadores? ¿El estándar hace algún comentario sobre intentar usar un operador miembro de esta manera?