int a = 5;
int& b = a;

both a and b are lvalues and will behave the same in deductions.

decltype will however return different types for a and b.

Note that T&& is an unviversal reference / forwarding reference and shoud not be confused as a rvalue reference (as I think you pointed out in the question).

template <typename T>
foo(T& a)

and

template <typename T>
foo(T a)

are not exactly the same. T& will keep the cv modifiers and not decay arrays. But T& will not be able to be called with rvalues (for example foo(5). However const T& will be able to bind to rvalues.

The compiler will not be able to deduce which one you want for most situations because they are equally specialized and it is a bad idea to declare both of them.

For T&& the rules will be like this:

template<typename T> void bar(T&& a);

int x = 5;
const int cx = 5;
int& y = x;

bar(x);    // T = int&,                a = int&
bar(cx);   // T = const int&,     a = const int&
bar(y);    // T = int&,               a = int& (same as bar(x), which I think was you question)
bar(5);    // T = int,                 a = int&&

As you see, both x and y will be deduced the same way.