Conversión implícita al sobrecargar operadores para clases de plantilla

Me gustaría saber por qué la conversión de tipo implícita no funciona con la sobrecarga de operadores externos en las plantillas de clase. Aquí está la versión funcional, sin plantilla:

class foo
{
public:

    foo() = default;

    foo(int that)
    {}

    foo& operator +=(foo rhs)
    {
        return *this;
    }
};

foo operator +(foo lhs, foo rhs)
{
    lhs += rhs;
    return lhs;
}

Como se esperaba, las siguientes líneas se compilan correctamente:

foo f, g;
f = f + g; // OK
f += 5; // OK
f = f + 5; // OK
f = 5 + f; // OK

Por otro lado, cuando la clasefoo se declara como una plantilla simple como esta:

template< typename T >
class foo
{
public:

    foo() = default;

    foo(int that)
    {}

    foo& operator +=(foo rhs)
    {
        return *this;
    }
};

template< typename T >
foo< T > operator +(foo< T > lhs, foo< T > rhs)
{
    lhs += rhs;
    return lhs;
}

Las siguientes líneas se compilan con errores:

foo< int > f, g;
f = f + g; // OK
f += 5; // OK
f = f + 5; // Error (no match for operator+)
f = 5 + f; // Error (no match for operator+)

Me gustaría entender por qué el compilador (GCC 4.6.2) no puede realizar una conversión de tipo implícita utilizando el constructor de conversión para la versión de plantilla de la clase. ¿Es ese el comportamiento esperado? Además de crear manualmente todas las sobrecargas necesarias, ¿hay alguna solución para esto?