Conversão implícita ao sobrecarregar operadores para classes de modelo

Gostaria de saber por que a conversão implícita de tipo não funciona com sobrecarga de operador externo nos modelos de classe. Aqui está a versão funcional e sem modelo:

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 esperado, as seguintes linhas são compiladas corretamente:

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

Por outro lado, quando a classefoo é declarado como um modelo simples como este:

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;
}

As seguintes linhas são compiladas com erros:

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+)

Gostaria de entender por que o compilador (GCC 4.6.2) não pode executar a conversão implícita de tipo usando o construtor de conversão para a versão do modelo da classe. Esse é o comportamento esperado? Além de criar manualmente todas as sobrecargas necessárias, existe alguma solução alternativa para isso?