MathUtils: let bringTo* deduce the type of the call they forward to

[ktf]

The parameter is a reference, so T is deduced with the address space attached,
and forcing that same T on a by-value parameter is a substitution failure on
Metal. Letting the inner call deduce its own type gives the same T everywhere
else, where the address space is not part of it.

[davidrohr]

But why is this needed? The existing code is even more explicit, so what is the problem?

[ktf]

As I understand it, bringTo02Pi(T& phi) deduces T as e.g. thread float — the address space rides along into T because the parameter is a reference, much like const would. But the explicit <T> then can't be fixed by matching it: to02Pi takes its parameter by value, and a by-value parameter may not be address-space qualified at all. Dropping the explicit <T> lets the inner call deduce its own T, which comes out as plain float because deducing a by-value parameter drops top-level qualifiers.

This is similar to:

template <typename T>
T to02Pi(T phi)          // by value, and it modifies a local of type T
{
  T res = phi;
  if (res < 0.f) {
    res += 6.283185307f;
  }
  return res;
}

template <typename T>
T wrap(T& phi)           // reference, so T picks up the qualifier
{
  return to02Pi<T>(phi); // forwards the reference-deduced T
}

int main()
{
  const float phi = -1.f;
  return (int)wrap(phi); // T = const float
}

which fails because the inner T is deduced as const float (whose mutation the compiler complains about). Dropping the <T> makes it work also in this case because the const is ignored when passed by value.

[ktf]

Builds. Merging.