Instead, use LocalIntegralEnergy and the newly introduced densities
for bulk models or planar shell models.

While doing so, give an error message when non-trivial volume loads
are requested.  I have no example file that actually uses them
at the moment, and just by looking at the code I find it hard to believe
that they actually worked.  Getting them to work will mean having
introduce a density for volume loads, which don't want to do
until I need them.

Since this is the last use of the CosseratEnergyLocalStiffness class,
this patch remove the entire class as well.

That way, we can also set the initial microrotation -- previously
it was hard-wired to the identity matrix.

Being able to explicitly choose the initial microrotation allows
to start, in particular, from a twisted strip.

Previously, the method basically hand-implemented a writer for
VTK files.  Using dune-vtk instead leads to much shorter and
simpler code, and gives us access to all the dune-vtk niceties,
like binary files and high-order grid cells.

Rather than the grid itself.  Because the grid view is all that
a writer needs to know about.

That way, a single Python file is enough to describe the entire
boundary value problem.

Rather than as our homegrown .parset.  That way, after more changes
this will allow to have the entire problem description in a single
file, including the boundary data.

They were expected to be the factors of a ProductManifold which is
also a template parameter.

Expecting the product and the factors is redundant.  We simply
extract the factors from the product now.

Previously, it expected two factor spaces, as separate template
parameters.  Taking a single ProductManifold type is more consistent
with GeodesicFEAssembler, and it allows to eventually generalize
the code to more factors, if desired.

... but disallow a plain pointer.  This increases consistency with the
GeodesicFEAssembler class.

dune-elasticity also has densities, but they implement a slightly
different interface.  Instead of having special code for such
densities in the LocalIntegralAssembler, add a wrapper that
makes densities from dune-elasticity look like dune-gfe densities.

There is no need to wrap the std::function that stores the
Neumann force density into a std::shared_ptr.

Plus some minor cleanup

This replaces the dedicated implementation of the quadrature loop
for harmonic energies -- that is not needed anymore.

In particular this means that the test for it can be removed.
In theory it should be replaced with a test for the harmonic
energy *density*, but that density implementation is so short
that it doesn't really require a separate test.

Rather than using preprocessor switches.  That's too fragile
and not extensible.

If the target manifold is a product space, then ProductManifold must be
used, and not a variadic list of the factor space types.

They do the same thing, essentially.

This is what the non-mixed ADOL-C assembler does, and I want to
merge the two.

The new method is Fufem::markBoundaryPatchDofs, which apparently
works in just the same way.

The ProductManifold class generalizes RigidBodyMotion, and can do
everything that the RigidBodyMotion class can.  Therefore there is
no point in keeping RigidBodyMotion any longer.  Having two
implementations for the same thing will just confuse people.

It was apparently not used.

If you should ever need something like this in the future,
please use periodicbasis.hh from dune-functions.

The old style has been deprecated for a long time, and is not
supported by dune-fufem anymore.

(In particular, the code discretizationerror.hh now requires
functions to satisfy the dune-functions function interface.)

In the wake of this, compute-disc-error.cc gets a number
of changes.  Let's hope I didn't screw up anything.

There are two important changes:  First of all, the new class implements
the `dune-functions` interface rather than the deprecated one based
on inheritance from `VirtualGridViewFunction`. Secondly, the new class
does not hard-wire geodesic interpolation anymore.  Rather, you can
give it interpolation classes which then govern how interpolation is done.

This change was long overdue.  It was now needed to make
gradient-flow.cc compile with the post 2.9 version of dune-fufem again.

The code erroneously used std::tie to combine two local variables
to a single return value.  That may fail because std::tie produces
a tuple of references.  Once the method has returned these references
may or may not be valid anymore.  I am surprised that this bug
has not caused trouble much earlier.

In particular:
- Use the CosseratVTKWriter also for MIXED_SPACE = 1, only print out the deformation though
- Use a SubsamplingVTKWriter only for dim==gridDim==3