See https://reuse.software/ for a description.

Moving all convergence check and output things to a class 'Iteration' that also
manages the InverseOperatorResult.

Depends: core/dune-common!551

Addresses: #50

IterativeSolver redefines one of the two overloads of apply(), which hides the other overload within
that class. This is then worked around in the overloaded variant.

This patch fixes the issue by making the non-overloaded variant visible in the context of
IterativeSolver.

These warnings are very irritating. They do not
warn about deprecated or misused feature. They are
issued any time you compile the tests. They don't
provide any useful information unless you look at the
code and have insight in the implementation detains.

To sum up: They don't look like a warning addressed to
the user, but like a reminder on an intended future
implementation addressed to the implementor. Hence
they should not be exposed to the user.

If anyone feels that this is an important user warning
feel free to re-enable it after adding enough information
making the warning actually useful.

depending on a preprocessor define we switch the base classes to be
pure virtual, or implement a dummy category(). If the classes are pure
virtual the old interface with an enum is not possible anymore.

To enable/disable the backwards compatibility check we provide a cmake
flag DUNE_ISTL_SUPPORT_OLD_CATEGORY_INTERFACE, which defaults to 1
(e.g. backwards compatibility enabled).

- we add helper code to extract the solver category from the enum
  or the virtual function
- we update the base classes to actually use this code to perform
  consistency checks

We introduce a new method category to check for the same SolverCategory of different
components at run time.

This is a drawback compared to compile time checks, but it adds a lot of flexibility as we will
be able to  write factory classes for solvers and compose/exchange solvers at runtime.

Besides this we added the following changes:
- an additional intermediate class IterativeSolver encapsulates the data of almost all solvers
- the solvers now inherit from IterativeSolver and can usually reuse its constructor
- the solvers now only have to implement _one_ apply method, the other is implemented
  generically

State:
- currently the example compiles
- none of the AMG headers has been updated yet

we introduced a template Parameter for the type counting the current
iteration. In general this is an int, but e.g. the BiCGStab print also
the intermediate steps, thus it uses double as CountType. As Markus
pointed out, the original name Int was not very intuitive.

this feature is necessary to keep readable output if we use funny value types, like Vc::double_v

This patch removes the assumption that the field_type and / or real_type
can always be implicitly converted to double and can be implicitly
constructed from an int (in constructs like field_type d = 0;).

This patch is required for compatibility with the FLOP counter in PDELab.