The original implementation measured the error of SO(3)-valued
functions in quaternion space in a few places.  This patch
converts another occurrence of this to matrix space.

That way, we can use 'if constexpr', and get suitable
writing methods for all kinds of TargetSpace, without
ugly preprocessor tricks.

The current implementation assign one degree of freedom to each
element, regardless of its type.  That only works for quad grids:
We are implementing Lagrange FE here, and these don't assign
degrees of freedom to triangles.

'Only' a stupid typo: '=' instead of '+='.

As of version 2.6, dune-functions doesn't properly do interpolation
of vector-valued functions with scalar-valued bases anymore.

The code it contains is adolcnamespaceinjections.hh.

I found those wrong types when trying to use a HarmonicEnergyStiffness
with a RigidBodyMotion.

In this case, two different refinements of the grids are not
necessarily geometrically identical.  This means we cannot
use hierarchic search with the global position of a quadrature
point, and expect to find the point on the other grid as well.

Instead, we go done to the coarsest grid, and make the transfer
to the other grid there.

Capturing any polymorphic object by value is wrong,
and gcc 8 started to warn about this in the case
of exceptions.

The latter is deprecated as of dune-functions 2.6.

It's the same code, but the old name is deprecated.

Running the test aborts with an error, because the error is exactly
the same as before this patch.

It is not actually used.

This is needed to build with a recent dune-common and dune-fufem

The main reason for this is that it is apparently needed for situations
where the grid dimension is not the world dimension.  It is a bit
shorter two.  I was hoping that it would also be faster, because we
eliminate an intermediate matrix object.  However, preliminary tests
have not shown any differences.

This makes the test build again.

It also removes the FD test for the gradient of the harmonic energy.
Since the HarmonicEnergyStiffness class does not implement the
gradient anymore, there is nothing to test here.

Previously, the error norms where computed in the respective global
embedding space of the TargetSpace.  For the case of Rotation<3>
this was the space of quaternions, because this is how the
Rotation class is implemented.  However, this does not lead to
correct results.  Therefore, this patch adds special handling
for Rotation<3>, and computes the errors norms in the space of
3x3 matrices.