This to clang for pointing out the problem.  I had not noticed it before
because the code was only wrong for dimworld<3, which I never tried.

This makes sequential cosserat-continuum compile again.

This makes mixed-cosserat-continuum compile again.

But keep compatibility with dune-grid 2.6 as well.

WARNING: These methods implement the projection in quaternion
space.  This is NOT the canonical projection in matrix space.

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.

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

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.

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.

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.

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.