¿Por qué gcc y clang producen resultados diferentes para este programa? (operador de conversión vs constructor)

Programa:

#include <stdio.h>

struct bar_t {
    int value;
    template<typename T>
    bar_t (const T& t) : value { t } {}

    // edit: You can uncomment these if your compiler supports
    //       guaranteed copy elision (c++17). Either way, it 
    //       doesn't affect the output.

    // bar_t () = delete;
    // bar_t (bar_t&&) = delete;
    // bar_t (const bar_t&) = delete;
    // bar_t& operator = (bar_t&&) = delete;
    // bar_t& operator = (const bar_t&) = delete;
};

struct foo_t {
    operator int   () const { return 1; }
    operator bar_t () const { return 2; }
};

int main ()
{
    foo_t foo {};
    bar_t a { foo };
    bar_t b = static_cast<bar_t>(foo);

    printf("%d,%d\n", a.value, b.value);
}

Salida para gcc 7/8:

2,2

Salida para clang 4/5 (también para gcc 6.3)

1,1

Parece que lo siguiente está sucediendo al crear las instancias de bar_t:

For gcc, it calls foo_t::operator bar_t then constructs bar_t with T = int.

For clang , it constructs bar_t with T = foo_t then calls foo_t::operator int

¿Qué compilador es correcto aquí? (o tal vez ambos son correctos si esto es alguna forma de comportamiento indefinido)