- Added stubs for ilu factorization factory, including stubs
  and reference implementations (which were provided by
  @hartwiganzt) for 3 kernels.
- Added core test for the ParILU Factory.

ParIlu factorization is now inheriting from `Composition` instead from
`LinOpFactory` (or similar).
Additionally, all added files are now also mentioned inside the
appropriate `CMakeLists.txt`.

- Added `get_l` and `get_u_factor` to ParIluFactors
- Fixed compiler errors for reference implementation
- Added simple test for reference implementation

- Renamed class to `ParIlu` (and the files accordingly)
- Added `iterations` variable to `ParIlu` to set the number of iterations
  of the compute kernel
- Extended both `core` and `reference` test
- optimized conversions (`system_matrix` -> Csr, Coo) by reducing the
  number of copies

- Added apply test for ParIlu
- Made all test matrices const
- Added additional reference tests for the 3 kernels
- Fixed wrong include file in `common_kernels`
- Fixed a mistake in the compute_l_u kernel (still not correct)
- Added comments to compute_l_u kernel
- Added debug output (MUST BE REMOVED BEFORE MERGING)

- All debug output was removed
- More tests were added (to cover most of the corner cases)
- Documentation was extended

Sorting of Csr matrices is required for ParIlu to work with any
kind of matrix input.
Currently, only the reference implementation is done. It is performed
with `std::sort` with a custom Iterator. That helps to prevent both
unnecessary copies and the need to implement a custom sorting algorithm.

- Moved (and renamed) the former CustomIterator (now IteratorFactory)
  to a separate file
- Added documentation to IteratorFactory
- Added tests for IteratorFactory
- Added tests for sorting in CSR
- Added sorting to ParIlu, so all tests succeed

The core test for ParIlu used kernels from the reference module,
which are not required to exist for the core tests. All relevant
tests were moved to the reference test.

Instead of having the same default value on all executors, it now
defaults to `0`, which means the implementation can freely choose
how many iterations are appropriate for the given ressources.

- Added used LaTeX packages into `Doxyfile-usr.in`
- Improved code coverage by adding tests for
  + `IteratorFactory` (specifically for the `operator<` in Reference)
  + `ParIlu` (Added additional test with sorted CSR matrix)
- re-added the overview description for `ParIlu`

To prevent conflicts with other users on the CI system, we now restrict
it to only use the first GPU (device ID 0) for all tests.

Note: That also restricts the CUDA executor copy test to a single GPU,
      meaning data will be copied internally on a single GPU instead of
      across devices.