Add mixins to help with constants and symbols

[chiphogg]

Constants (#90) and symbols (#43) have a lot of similarities. For
example:

• Multiplying by a raw number produces a quantity.
• Multiplying by a quantity changes the units of the quantity.
• They can compose with other instances of the same family (e.g., the
  product of two constants is a constant).

Let's use the term "wrapper" to refer to constants and symbols here. To
make each wrapper as easy as possible to implement, I've created some
"mixin" classes, each of which adds the full set of multiplication and
division operations for a single combination of the wrapper and some
other family of types (raw numbers, quantities, other wrappers, etc.).

These wrappers use a "CRTP-ish" syntax. But instead of the type
itself being the first template parameter (e.g., Wrapper<Unit>), we
provide the wrapper and unit as two separate parameters (i.e.,
Wrapper and Unit). The reason is that we need to know the Unit,
and providing it explicitly makes it easy to get. These first two
parameters are the same for all mixins, which makes the list-of-mixins
at the class definition easier to read.

The unit tests are based on an example, UnitWrapper, which aggregates
a variety of properties. The forthcoming "true" classes, Constant and
SymbolFor, will be defined very similarly to this.

Finally, a word about the plan for "numeric" inputs. For now, we are
restricting to std::is_arithmetic. This doesn't mean we don't support
other reps; it just means we won't be able to create quantities from
them via constants or symbols for a while. The evolution plan is to
create a well-defined concept that defines what is a valid rep, and then
replace std::arithmetic with that concept (see also #52).

Test plan:

• Add extensive new unit tests
• Manually uncomment each individual "uncomment to test" case

[chiphogg]

Note to reviewers: this is probably the best starting point. The goal of this PR is to enable us to write something like this. The test cases below demonstrate what capabilities this kind of definition provides. Then, with that motivation, you can check out the implementations in the previous file.

[geoffviola]

Makes sense. The concept-like implementation is interesting. The tests look good.