I wrote them years ago mainly because I thought they should exist.
But they were never actually used them for anything, and I don't
really know were they could be used either.  Supposedly they
could be useful for implementing problems without a minimization
formulation, but that's not currently planned, and I don't know
what the precise requirements would be, either.

Since the code is short and almost trivial, and easily resurrected,
this commit removes the two files.  For newcomers this will mean
two less files to wonder about.

It is default-implemented in LocalDensity itself, and therefore
density implementations don't have to implement it themselves
unless they need to do something nonstandard.

Rather than just on the type for points in the domain.
The point type is not enough: For example, if the density involves
a coefficient function given as a GridView function, then the
density has to be able to bind the local coefficient function
to the correct element, for which it has to know the element type.

Integration domains can be elements (i.e., Codim<0>::Entity)
or Intersections.

The actual bind method will follow in a separate commit.

I suspect that calling the density through LocalDensity::operator()
doesn't work yet, because the GFE function derivatives are not
transformed correctly from the reference to the grid element.
Therefore that new method still aborts with a deliberate error
message, until I have the time to check.

This allows to fix the incorrect coordinate type that was expected
for evaluating the density.

Currently, densities only get the type used for coordinates
of the integration domain.  However, this is not enough:
The complete domain must be known, and this domain can be either
a grid element or a grid intersection.

As a first small step, this patch introduces ElementOrIntersection
as a template parameter of the CosseratShellDensity class.

This is one step towards turning SurfaceCosseratEnergy into a
generic SurfaceIntegralEnergy class.

They are unused -- all code uses the space-dependent parameters.

For my current clang 19.1.5 they are an error.

Previously, the code would write the reference deformation and the
final orientation.  This patch replaces the reference deformation
by the final deformation.

This is still wrong, because the CosseratVTKWriter expect the
displacement, not the deformation.  That problem is left for later.

This can be used in makeComposedGridFunction to turn quaternion-valued
functions to matrix-type ones, and vice versa.

It computes buckling under a axial compressive displacement load.

The compute-disc-error program reads this to compute discretization
errors.

Doing the data transfer via VTK files would be more convenient,
but that involves a resampling which I'd rather like to avoid.

Previously, the writer requested an FE basis to represent the director
vectors.  With the help of ComposedGridViewFunction this patch allows
to avoid this extra basis, which makes for a much nicer interface
for CosseratVTKWriter.

It is only used by `film-on-substrate.cc` which many people
do no use.

The NonplanarCosseratShellEnergy class contains a reimplementation of
the energy density of CosseratShellDensity.  The code is much easier
to understand and maintain if the density implementation of
CosseratShellDensity is used instead.

... and with constant Lamé parameters.  In many applications
there are constant, and it is convenient to be able to exploit that.

For some reason there were two code paths for the creation of the
solver object: One for dim==dimworld, and one for dim!=dimworld.
These shouldn't really differ, though, and indeed they didn't
as far as I can tell.  Theremore, merge the two code paths.

That is one step towards splitting off the energy density
into a separate class.

Also, it helps to unify the code paths for the different grid dimensions
in cosserat-continuum.cc

And use it in the dim==dimworld part of cosserat-continuum.cc.

For this test to be really helpful it has to use curved grids.