[Ordering] Implement a real fix for statically blocked leaf spaces of size 1

Recent experiments with Taylor-Hood type DG spaces for Navier-Stokes
have uncovered a bug in the interplay between the new ordering
infrastructure and the support for block matrices: If a leaf
spaces (e.g. the pressure space in the case above) is statically
blocked, the ordering infrastructure will create an additional block
level in the corresponding ContainerIndex entries. That works fine as
long as the block size is larger than 1, but if it is exactly 1, the
additional block level clashes with an optimization in the ISTL
backends. For last-level blocks (FieldVector / FieldMatrix) of size 1,
the algorithms for accessing container entries assume that the final
index (which will always be 0 for size 1) has been optimized away. That
creates a rather nasty misunderstanding which results in invalid memory
accesses and / or failed assertions.

We could just say: Don't use static blocking if your block size is 1,
but that can be inconvenient sometimes (e.g. in the example above for a
space pair with order 2/1 you need blocking for all parts, for 1/0 you
only need it for the velocity components).

I attempted an initial fix in 0a38f9227e64, which just went ahead and
ignored the blocking request in the VectorBackend for block size 1, but
as it turns out, that creates the next set of problems when you use such
a backend for a PowerGFS or a CompositeGFS and want to statically block
the DOFs of their children. In that case, you don't want to explicitely
specify the block size (as it can be deduced using a TMP), but as the
block size defaults to 1, the initial fix turned off blocking in that
case, but didn't do so correctly, resulting in really nasty bugs in the
linear solver.

So this patch tries to be a little more clever, albeit also more
invasive: We always accept the user's statement about the blocking type
at compile time, but try to be more clever at runtime by exploiting the
fact that the orderings only store the blocking state as runtime
information. For a correct decision, we need to know whether the
underlying GFS is a leaf space or an interior space, so this patch
changes the signature of the VectorBackend::blocked() method to receive
the GFS from the transformation descriptor. That way, we can switch off
blocking for leaf spaces with block size 1, but keep it active for
interior GFS nodes.

There is one drawback to this approach: The maximum number of index
components in the ContainerIndex is extracted from the compile-time
information to determine the capacity of a ReservedVector, so
static blocking of a leaf space with block size 1 will cause those
vectors to be one entry longer than they have to be, but the performance
impact of that size overhead should be absolutely minimal.