Math: slightly reorganize Quaternion test.
Math: ability to explicitly create Quaternion for given vector.
Math: rotating vectors with Quaternion.
Math: rename Quaternion::fromRotation() to rotation().

Now it is similar in usage to Matrix4 functions and is now also
crossreferenced in documentation. Also updated the test to also check
assertion.
Math: various code cleanup.
Math: properly test Quaternion comparison.
Math: dual number implementation.
Math: Allow division of Dual with Dual of another type.

Will allow dividing Dual<Quaternion<T>> with Dual<T>.
Math: return proper type from Dual operators in subclasses.
Math: Use default pure equality comparison for arbitrary types.
Math: initial implementation of DualQuaternion class.

Currently practically unusable.
Math: document that Quaternion::rotationAxis() might return NaN vector.
Math: creating rotation and translation DualQuaternion.
Math: better documentation for vector/quat constructors.
Math: creating DualQuaternion from vector.
Math: simplified Quaternion::rotateVector*() tests.

Comparing to Matrix4 transformation.
Math: ability to also multiply Dual with Dual of another underlying type.
Math: convenience function to transform points with DualQuaternion.
Math: convenience functions for transforming vectors with matrices.

It's now possible to conveniently transform 2D vectors and points with
3x3 matrices and 3D vectors/points with 4x4 matrices. Previous most
low-level solution:

    Matrix4 m;
    Vector3 v;
    Vector3 a = (m*Vector4(v, 1.0f)).xyz();
    Vector4 b = (m*Vector4(v, 0.0f)).xyz();

Another, more generalized solution for points was with Point2D/Point3D,
adding a lot of confusion (what is that class and what does .vector()?):

    Vector3 a = (m*Point3D(v)).vector();

And the worst solution was with generic 2D/3D code (WTF!):

    auto a = (m*typename DimensionTraits::PointType(v)).vector();

Now it is just this, similar for both dimensions:

    Vector3 a = m.transformPoint(v);
    Vector3 b = m.transformVector(v);

Note that transformation three-component vectors with 3x3 matrices or
four-component vectors with 4x4 matrices is easy enough so it doesn't
need any special convenience functions whatsoever:

    Vector3 c = m.rotation()*v;
Math: added tests for composed dual quaternion parts.

To be sure everything is implemented properly.