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.

The CI system found this for me, because it only goes wrong
when dune-foamgrid is not available.

The interface of Solvers::IterativeSolver used to make its
iterationStep_ member publicly available.  This has changed,
and the iteration step can now only be accessed by a getter
method (which is good).  However, that getter returns a
reference, but not the full smart pointer.

See the discussion at

  https://git.imp.fu-berlin.de/agnumpde/dune-solvers/merge_requests/23

In theory this is dangerous, because a pure Newton method will
only converge locally.  However, the trust-region part had been
partially disabled anyway, and I have not noticed any problems.
Also, I think that from my well-posedness result for higher-order
GeoFEs follows that a Newton method will always converge if the
problem is well-posed (that is how the proof works, after all).

On the plus side, this patch brings roughly 5% speed increas.

These Hessians are always symmetric, and we should really
exploit this.

Additionally, it seems that the method was never used anyway.

This is necessary to compute H1 errors in matrix space.

This used to work, because the matrix is 1x1 anyway (with corresponding
vectors), but some time ago the matrix and vector assignment
in dune-common was reworked, and now the code does not compile
anymore.

In many cases it is not needed, but I am too lazy to write
a proper test for it right now.

Good to measure whether there is locking, and whether the code works
at all.

gcc warns about some of those nowadays.

This got introduced in dune-grid 2.6.

In particular, MonotoneMultiGridStep use shared_ptr much more
frequently now.  Also, various of its data members are now
protected, and getters/setters have to be used.

It used to be in dune-functions originally, but got moved to
dune-common eventually.  This patch updates the code to reflect
that move.

Otherwise some dune-common stuff will not work properly,
for example copying of FieldMatrices that use adouble
as their number type.

I think they used to have one, back in the day of the EntityIterator
class.

Transformed the surrounding loop to range-based-for syntax
while I am there.

The method indexSet has been removed from dune-functions
a long time ago.

The one in the Arithmetic namespace does not exist anymore.