[Adaptivity] Lots of minor cleanups in preparation for full GFS tree support

The backup and replay functionality of the adaptivity support was doing
things in very convoluted and non-obvious and non-optimal ways.

This patch cleans up some of the most confusing / inefficient issues
with the least amount possible to avoid introducing additional subtle
bugs while adding tree support:

- Don't store L2 projection matrices as vectors of vectors - we have
  DynamicMatrix for that purpose.

- The CoeffsToLocalFunctionAdapter used to store a reference to its
  first constructor parameter. The original object pointed at by that
  reference then got assigned different values outside of the function,
  which in turn influenced the behavior of
  CoeffsToLocalFunctionAdapter. After spending half an hour
  to understand this weird scheme, it's now gone and replaced by an
  internal updatable pointer. In order to update the contained
  information, users call the new method setCoefficients(). That's still
  a strange way of programming, but at least it's a little less surprising.
  As an added bonus, the type of the coefficients is now a template
  parameter,
  which we will use to stuff in either a DynamicVector (during backup)
  or a std::vector (during replay) in there.

- Don't use a map and (!) a set to store projections and the fact that
  they exist. Just use a std::vector indexed by GlobalGeometryTypeIndex
  instead. Matrices with nonzero sizes indicate prior initialization.

- Avoid creating, deleting and copying excessive numbers of std::vectors
  during backup and replay.

- Generally avoid creating temporary objects that do heap allocations
[LFSIndexCache] Make leaf size extraction more generally useful

The leaf size extraction support used by LFSIndexCache can be useful in
different places, but is currently closely tied to the needs of the
LFSIndexCache.

This patch improves on the current situation by switching to an
iterator-based interface so we can handle different types of containers
and adds a wrapper function extract_lfs_leaf_sizes() to hide the
creation and application of the visitor.
[Adaptivity] Rewrite backup / replay components to support GFS trees

This patch is an almost complete rewrite of the existing backup / replay
functionality:

- Switch to visitor-based architecture to be able to support trees of
  function spaces

- Remove CoeffsToLocalFunctionAdapter. It's more efficient to explicitly
  code out its functionality in the two places it is needed because
  doing so avoids lots of unnecessary basis function evaluations

- Improve inverse mass matrix cache to store multiple matrices (one per
  leaf) and replace homebrewed matrix and inversion with DynamicMatrix

- Avoid projecting onto coarse elements more than once

- Code is mostly robust w.r.t. hybrid meshes / complicated FEMs. To make
  the code work in those circumstances, we probably need FEMs that return
  the finite element by value, though...

- Avoid second grid traversal during replay just to normalize data. We
  can do that by simply iterating over the two containers with data and
  weights.

- make integration order for mass matrix configurable.

- make it possible to set limits on the min / max refinement level
  during grid adaptation.
[Adaptivity] Some fixes to GridOperators to allow reuse after adaptation

Both the BorderDOFExchanger for the nonoverlapping version of the
standard GridOperator and the const residual for the OneStepGridOperator
need to be updated when the underlying GFS changes.