When calling CHOLMOD to compute the Cholesky factor of a matrix,
it was not tested whether such a factor already existed. As a
consequence, if the solver was called twice in a row, the old
factor would be lost to a memory leak.

Fix this by explicitly deallocating the old Cholesky factor
before asking CHOLMOD for a new one.

Use fixed seed instead of clock value to make results of
blocked and non-blocked version and results of different
test runs comparable.

The internal operations of `FastAMG` assumed that the entries
of the matrix are vectors are matrices and vectors themselves
by making use of the dune matrix and vector interfaces. As a
consequence `FastAMG` cannot be used with `BCRSMatrix<double>`
in contrast to `BCRSMatrix<FieldMatrix<double,1,1>>`.

This patch introduces `IsNumber`-based switches in the respective
places that use plain arithmetic operators if the matrix/vector
is not blocked thus adds the missing support for e.g. `BCRSMatrix<double>`.

A static cast in vc deriberately says, that the third
and forth template parameter must not be set manually.
Hence this patch disables the tests where this is done.

`Simd::cond(a,b,c)` only has overloads for the cases where
`b` and `c` have the same type. If this is not the case
(which seems to happen for certain distributions and compilers)
the compiler cannot deduce the template parameter for the type.

It turns out that in all cases where this happens, the first
argument is constructed by explicitly casting to a type. In
all these cases the present patch adds a cast to this type
for the second argument, too.

WARNING: I did not look at what the actual code does. However,
if the implementation of `Simd::cond()` makes and the existing
cast make any sense, that's the only possible type we can commit to.

When throwing a `MatrixBlockError` the `DUNE_THROW` macro was
abused to also set the data members of `MatrixBlockError` by
referring e.g. to the local (in macro) variable name `th__ex`.
I consider this a bug, since these are undocumented implementation
details. Furthermore their use prohibits any change to `DUNE_THROW`
e.g. to make it `constexpr` friendly.

SuperLU 7.0.0 now uses singlecomplex instead of complex and by default
does not add a typedef to make singlecomplex available as type
complex. The latter was used in previous versions.

As we need to support several versions of SuperLU we force adding such
a typedef by defining SUPERLU_TYPEDEF_COMPLEX

* Handle float exception handling for MSVC
* Remove system specific includes
* Make iterator in block vector be copyable to fulfill output iterator interface

getMatOrThrow handed out a reference to the underlying matrix, but for
the compiler it was undecidable, whether this might be a dangling
refernce. This lead to many warnings. We now hand out the
AssebledLinearOperator and call getmat explicitly where ever needed.

In the rewrite the vector types of UMPack were checked, similar to the
other direct solvers. This does not work anymore, as recent changes in
UMFPack now lead to a compiler error if the vectors are not available,
i.e. when using a real-type different from double. This change now
(re-)introduces a SFINAE check to ensure that the types are compatible.

Found by GCC (Wcatch-value)