Refactor get_value<T>(m) to enable success query

[chiphogg]

Right now, get_value<T>(m) for a magnitude m either produces the
requested value, or invokes a hard compiler error via static_assert.
It would be nice if we had a way to ask whether this operation would
succeed. For this purpose, we now provide representable_in<T>(m).

It turns out that we can't actually answer this question without
effectively doing all of the work to compute the value. We won't want
to do this twice, because that would uselessly slow down compile times.
Therefore, we extract all of our logic into a common implementation
function. The logic is basically equivalent to the pre-existing version
of get_value<T>(m), except that instead of each static_cast, we
return a unique value of a new enum we created for this purpose.

This means that each function can get its result efficiently. For
get_value, we change the trigger for each static_assert to the
corresponding enum value. For representable_in, we simply check
whether that enum has the OK value.

This PR helps pave the way for #90. When we make our Constant class
implicitly convertible to Quantity types, it turns out that we can do
better than the "overflow safety surface"... because we know the exact
value! We can achieve perfect compile-time checking. This PR will give
us a single function that we can call in our implementation for that.

Includes docs and tests.