Let’s be honest, I’m never gonna use it in its current form.

This new version allows to compute odd and even double factorials
without harming performance for the standard factorial.

Most operators do not yet handle reals of different sizes, but
this change fixes the most glaring bugs.

It was hard to avoid some of the compiler optimisations caused by our
intermediate conversion to double, so we hide them behind the actual
real object. Also, this commit fixes a potential exponent overflow.

Now that the exponent is no longer biased, it is a signed number, and we
need to account for that when dividing it and expecting rounding rules to
behave in a certain way.

Some checks are failing, I probably messed up several functions.

By adding a bias we ensure that 1.999… will be displayed as 2.0 as long as we
do not ask for too many digits, and that rounding is reasonable for most values.
Note that our need for proper rounding is not as high as for IEEE floats since
we have an insane amount of digits at our disposal.

Also we now get rid of trailing zeroes when printing reals.

We already have the convenient degrees() and radians() functions to convert
between angle formats. This commit involves a lot of refactoring here and
there and I may have missed some places where conversions were needed. But
hopefully there aren’t may such places.

The name “re” came from “reciprocal” but since we have “inverse” for
matrices, I thought it would be nice to make everything consistent.

This lets us use the code for non-float variable types. I also got
rid of the mat4-to-quat code so that users are forced to use the
mat3-to-quat code and possibly discover places where their code is
suboptimal.

Using “Array” instead of “array” is now fully deprecated, and I replaced
the Log::Debug() etc. functions with msg::debug() etc. because log:: was
unavailable due to being a maths function.

Added up-to-date copyright notice and BOM to modified files, just in case.

The containers no longer force the user to use the ptrdiff_t type for
size information. For convenience, size() now always returns an int,
and the size_s() method offers a way to handle arrays with more than
2 billion elements. Internally, we still use ptrdiff_t, though.

Since so much code had to be changed, I took the opportunity to get
rid of capitalised accessors for classes that are lowercase.

support for enable_if and other template metaprogramming techniques),
for Clang (related to static const template class member initialisation)
and for GCC (related to forward declaration of non-int enum classes).