... instead of binding to LocalFiniteElement objects.

This is how binding works everywhere else, too.  In addition,
in frees us from the difficult task to always get the
appropriate LocalFiniteElement objects to bind to.

... instead of always constructing a local LocalGeodesicFEFunction
object. This makes the class consistent with all similar assemblers.
It also removes the hardwired 'geodesic' interpolation rule.

Unfortunately, this commit contains a bit of whitespace change.

Because it was way more boilerplate code than actual code.

This is what the other energies do.

This is the basis used as interpolation weights (for geodesic
FE functions) or for interpolating in the embedding space
(for projection-based FE functions).  The basis is not actually
used yet, but it needs to be given to the class in the
constructor.

Rather than constructing objects locally.

Rather than as a std::unique_ptr.  The unique_ptr was introduced
because originally it was not possible to construct a
LocalGeodesicFEFunction without also binding it.  As this has now
changed we can get rid of the extra allocation required by
std::unique_ptr.

Rather, expect them as constructor arguments.

Instead, expect to be given one from the outside.  This is one
more step towards making local interpolation rules more like
local functions.

As one further step towards making LocalInterpolationRules
more like (local) functions, introduce a new method 'bind'
accepting a local finite element and a set of (local)
coefficients.  This method replaces the constructor
taking the same arguments. Instead, the local function object
now has to be default constructed.  This is just an
intermediate step, however.

Instead of hard-coding LocalGeodesicFEFunction.

MixedGFEAssembler is not part of an inheritance hierarchy.

It doesn't look like this code ever worked.

There is a generic mechanism for surface loads in form of the
NeumannEnergy class (to be replaced soon(TM) by something
even more generic).  This is what should be used, instead
of ad hoc implementations such as the one in SimoFoxEnergy.

Because it is an energy, not a local stiffness.

It was non-virtual by oversight.

Rather than a LocalFiniteElement.  This makes LocalGeodesicFEFunction
more like a dune-functions-style local function, which I think
it should be.

Rather than a LocalFiniteElement.  This makes LocalGeodesicFEFunction
more like a dune-functions-style local function, which I think
it should be.

I don't think it is worth keeping it, even if it may be
a bit faster than the general code.

The class LocalGfeTestFunctionBasis was removed in a recent commit,
and I forgot to remove a friend declaration for it.

This patch contains only whitespace changes.

Previously, some code was in Dune::GFE, some was in Dune::,
and a lot of it was in the global namespace.

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.