Previously, the actual projection happened by calling the constructor
of one of the classes that implements points on a manifold.  This patch
introduces an new method projectOnto, which makes the projection more
explicit.

- use more shared_ptr
- New MCMGMapper interface from dune-grid 2.6
- basis.indexSet() has been removed from dune-functions

Makes it faster, but only by 1 or 2 percent.

The new value is what you need for linear target spaces.
I am not convinced that this is sufficient, but it matches
what we do for simplices.

The whole quadrature business will need some theoretical
investigations eventually.

Only cmake is supported from now on.

A lot of raw pointers have been replaced by std::shared_ptr.

A lot of data members are inaccessible now, and getters have
to be used.

A small patch is still needed for dune-solvers: The iterationStep_
member is still needed to be public, because the new getter only
grants access to the object, not the pointer to it.

Make them a parameter instead.  This allows to switch more easily between
geodesic finite elements and projected finite elements.

Make them a parameter instead.  This allows to switch more easily between
geodesic finite elements and projected finite elements.

It still tested for the dune-fufem wrapper of a first-order basis, while nowadays
the RiemannianTRSolver class is instantiated with dune-functions bases.

It is still no function in the dune-functions sense, but at least the
basis parameter needs to be a dune-functions basis now, rather than
a deprecated dune-fufem basis.

This is needed to be able to multiply FieldMatrices with Quaternions.

Needed for gradient-flow applications.

According to Hanne, this is needed to turn 1d harmonic map heat flow into true
curve-shortening flow.

Hardwiring the weighting here is very hacky.  Something more flexible and
general will need to be implemented eventually.

Apparently, nobody had used the evaluateDerivativeLocal method before.

This are needed by the gradientflow code to implement the implicit Euler method
for an L2 gradient flow.

This is an initial version; it currently only works for a very limited set of
cases.  I tested it for triangle grids, and that works.

This is needed for the new gradientflow application.  The standard 'distance' method
doesn't cut it, because it is not differentiable near zero.  Therefore, even the
differentiable expression 'distance*distance' will fail to be differentiable for
an automatic-differentiation system.  I think in the long run we should replace
'distance' by 'distanceSquared' everywhere it is used.

Unfortunately, this patch is hacky: it only adds the method for the double/adouble
combination.

Previously, the NonplanarCosseratShellEnergy had the normal field of the unit sphere
hard-wired in the code.  With this patch, using general triangulated surface as
reference geometries is possible.