fix implicit conversion table for references

It should follow compiler's behavior.

Test code:

```d
alias /*MutableOf         */ M  (T) = T;
alias /*ConstOf           */ C  (T) = const(T);
alias /*SharedOf          */ S  (T) = shared(T);
alias /*SharedConstOf     */ SC (T) = shared(const(T));
alias /*InoutOf           */ W  (T) = inout(T);
alias /*InoutConstOf      */ WC (T) = inout(const(T));
alias /*InoutSharedOf     */ WS (T) = inout(shared(T));
alias /*InoutSharedConstOf*/ WSC(T) = inout(shared(const(T)));
alias /*ImutableOf        */ I  (T) = immutable(T);

alias Seq(T...) = T;
alias Quals = Seq!( M   ,  C   ,  S   ,  SC  ,  W   ,  WC  ,  WS  ,  WSC ,  I   );
alias Names = Seq!("M  ", "C  ", "S  ", "SC ", "W  ", "WC ", "WS ", "WSC", "I  ");

void main()
{
    import std.range, std.array;
    pragma(msg, "    ", Names.chain.array);
    foreach (i, F; Quals)
    {
        pragma(msg, Names[i], {
            string r;
            foreach (T; Quals)
            {
                // Test conversion, eg. from const(int)* to immutable(int)*
                r ~= is(F!(int)* : T!(int)*) ? " Y " : " N ";
            }
            return r;
        }());
    }
}
```