¿Es posible inicializar la clase interna de una plantilla en la cláusula “requires” de C++20?

Considere la siguiente clase A que define una clase interna de plantilla B:

struct A {
  template<class =="" int="">
  struct B { };
};

Podemos usar la siguiente expresión para inicializar la clase interna B, donde typename es opcional: (Godbolt)

int main() {
  A::template B<>();
  typename A::template B<>();
}

Quiero usar conceptos para detectar si un tipo tiene una clase interna de plantilla B:

template<class t="">
concept C = requires {
  typename T::template B<>();
};

static_assert(C<a>);

Pero solo clang aceptó el código anterior, GCC y MSVC lo rechazaron debido a un error de sintaxis (Godbolt):

<source>:8:27: error: expected ';' before '(' token
    8 |   typename T::template B<>();
      |                           ^
      |                           ;

Y si elimino el typename en la cláusula require:

template<class t="">
concept C = requires {
  T::template B<>();
};

MSVC lo acepta, pero Clang y GCC producirán una “declaración de aserción estática fallida” ya que consideran que la expresión no está bien formada (Godbolt):

<source>:11:15: note: because 'A' does not satisfy 'C'
static_assert(C<a>);
              ^
<source>:8:15: note: because 'T::template B<>()' would be invalid: 'A::B' instantiated to a class template, not a function template
  T::template B<>();
              ^

¿En qué compilador debería confiar?