Function templates with `auto ref` parameters can’t be explicitly
instantiated, but must be IFTI’d to infer `ref`-ness of `auto
ref` parameters.

When doing meta-programming, that is annoying. Some template
might have verified that some alias refers to a function template
and that it can be called with the kinds of arguments the
template wants to use. Great job, D, for making this rather easy!
However, for some reason, we need a function pointer (or
delegate) to the respective instance. That is always possible,
except if the alias is to a function template with `auto ref`
parameters.

We should find a solution to this. It does not have to be pretty,
there should be just *some* way to do it.

The ideal test case is a function template with a sequence
parameter and `auto ref` on non-template-argument-type parameters:
```d
void example(Ts...)(auto ref int arg, auto ref Ts args) { }

auto fp = &example/*YOUR IDEA*/;
```

One way I thought could work is just passing `ref T`:
`example!(ref long)`, but that doesn’t work for the `int`
parameter.

While I think the following looks okay, it occupies the syntax
`![]` which we might use for something more useful:

```d
auto fp1 = &example![ref](); // void function(ref int)
auto fp2 = &example![auto](); // void function(int)

auto fp1 = &example; // void
function(ref int, char, ref wchar)
auto fp2 = &example; // void
function(int, ref char, wchar)
```

While required for explicit function template instantiation, even
IFTI can profit from it: Not every lvalue argument should be
passed by reference.
```d
int x;
example(x); // Full IFTI: `ref`, Ts empty
example!()(x); // Partial IFTI: infers `ref`, Ts empty, same as
above
example![ref]()(x); // No IFTI: `ref` explicit, Ts empty, same as
above
example![auto]()(x); // No IFTI: `auto` means not `ref`. Pass `x`
by value/copy

```