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.

For some reason clang doesn't like it, and we are not using OpenMP anyway.

This allows to select the energy at run-time, but this is not what we do.
It also allows to give extra parameters to the nonplanar Cosserat energy,
and that is what we need: in a subsequent patch the main program will compute
a surface normal field and pass it to the Nonplanar Cosserat energy.

I want this file with dimworld!=3 grids, even though it only makes sense
to use it if dimworld==3.

With this patch the file still does not compile.  However, the only remaining
problem is the hacky computation of the surface normals, which needs to be
rewritten in full generality soon anyway.

Here is a new program that does nothing but compute discretization errors:
that is L2 and H1 norms of differences between two functions.  The reference
function can be either discrete or given in closed form (the latter is not
enabled yet).

So far I have only used this program to measure discretization errors of
Cosserat shell models, and I did *not* get the error behavior I expected.
So either the error behavior of such shells is weird, or this new measurement
program is still buggy.

We can now completely control the approximation order by a const int,
which is much nicer.

This data is used by the compute-disc-error program to measure discretization errors.

The method using the SVD works in principle.  However, it does not play nicely
with automatic differentiation, because singular values are not always differentiable.

The method proposed by Higham to compute the polar factor, on the other hand,
is a Newton method at heart.  Therefore, it can be used together with AD without
problems.

They only make sense if the 'adouble' type is known.

I intend to move as much towards the dune-functions interface for functions,
and this is a first step.

Introduce preprocessor variable PROJECTED_INTERPOLATION to switch between geodesic FE and projection-based FE

This is a temporary solution; we need something smarter eventually.

Rationale
a) Code is much simpler without it
b) Code compiles faster without it
c) P3 functions are now downsampled to P2 functions, rather than to P1 functions.
   Hence there is less loss of information now.

Simply ask the first local finite element of the dune-functions basis for the order.

In particular, assemblers now hand LocalView objects around, rather than pairs of
elements and LocalFiniteElements.

Introduce a dedicated class LocalQuickAndDirtyFEFunction to produce initial iterates for the GFE minimization problems

Previously, a LocalProjectedFEFunction was used for this.  This turned out to be a bad idea for two reasons:
- Evaluating such a function can actually pretty expensive.  For example,
  to project onto SO(3), the polar decomposition needs to be evaluated by
  an iterative method.
- Screwing up the LocalProjectedFEFunction implementation can actually screw up
  the GFE implementation as well in very subtle ways.  Specifically, if the
  LocalProjectedFEFunction is not ADOL-C-differentiable, then the GFE function
  will not be differentiable, either.  This fact cost me a few hours searching...

Because these two classes are for the most part identical.

Currently, this merged version involves some trickery, including some template
specializations and multiple inheritances.  I hope to get rid of that, eventually.

This is how the new dune-functions bases should be used.  Also, it is yet
another step towards merging CosseratEnergyLocalStiffness and MixedCosseratEnergy.

This model was given to me by Patrizio Neff in private communication.

The code is a prototype.  It appears to work, but it has not been tested very
thoroughly, and quite likely there are some bugs left.  Also, the code contains
the shape of the reference configuration hard-wired (a sphere).

This patch adds several more implementations of operator+ etc for FieldMatrices.
In particular, you can now combine matrices of adoubles (the 'active' type from
the ADOL-C automatic differentiation library) with regular double types.

These new operators are needed for the NonplanarCosseratShellEnergy class,
which is coming in the next patch.

The old version kept was too big, and kept a useless row of zeros around.
Removing this row should lead to a tiny increase in efficiency.  More importantly,
it gets us closer to the CosseratEnergyLocalStiffness class again, which
is scheduled to replace MixedCosseratEnergy eventually.

This leads to some simplification

This is an important step towards making the 'mixed' Cosserat code more like
the regular one.  The mid-term goal is to merge the two implementations, because
there is way too much code duplication here.

The DR variable (the derivative of the microrotation R wrt space) had dimensions 3x3x3.
This is two big in a shell context, because there are actually only two space dimensions.
Hence the correct size is 3x3xgridDim.

The results without this patch were not wrong, though, only a bit wasteful.

It is needed for shell problems with non-planar reference configuration.

This makes 2nd-order orientation functions work again.