Fixes a regression from 1e3fc3b: the Boost version depends on
the CUDA version for Intel, therefore CUDA must be loaded first,
but the CUDA version depends on the C++ version, so C++14 must be
defined at the top of the file.

The user can now provide the name of the CUDA compiler as a CMake
flag instead of modifying CMake variables to bypass the guessing
mechanism. CMake fails if the selected compiler is not found. The
FindCUDACompiler helper file was split into separate .cmake files.

The minimum CUDA version is 9.0 for NVCC and 8.0 for Clang. For the
Clang compiler and the Clang-based HIP compiler, the minimum version
that is tested in CI is 6.0.0.

The ESPResSo CMake project now has proper dependencies for every
target in the source code, documentation and tests. It is no longer
necessary to delete the build directory to start a fresh build.

Explicitly toggle GPU code on/off with WITH_CUDA and select the
compiler with WITH_CUDA_COMPILER.

With the CUDA compiler guessing mechanism removed, the user must
explicitly states if CUDA is available and which compiler to use.

In ROCm 3.0 and 3.1, environment variables for hipcc and hcc are
overriden by incorrect paths (espressomd/docker#156). This causes
CMake to generate an incorrect linking command for EspressoCore.so:
in `/opt/rocm/bin/hipcc_cmake_linker_helper /opt/rocm -fPIC ...`,
either path `/opt/rocm` is an empty string, or both the linker path
and path `/opt/rocm` are empty strings. Calling `find_package()`
twice with an overriden `HCC_PATH` fixes the linking command.

Knowing the CMake version is extremely useful when reviewing CMake
logs attached in bug reports.

The C++ standard used for CUDA code is set in `CMAKE_CUDA_STANDARD`.
Variable `CMAKE_CUDA_VERSION` was renamed to `MINIMAL_CUDA_VERSION`
for clarity.

The nvcc `-O<N>` optimization flag can only take a number.

Cannot compile CUDA code with coverage enabled using Clang.

Rewrite CUDA flags based on the CXX flags:

CMAKE_CXX_FLAGS_DEBUG = -O0 -g
CMAKE_CXX_FLAGS_RELEASE = -O3 -DNDEBUG
CMAKE_CXX_FLAGS_MINSIZEREL = -Os -DNDEBUG
CMAKE_CXX_FLAGS_RELWITHDEBINFO = -O2 -g -DNDEBUG

Add a COVERAGE build type that uses -O0 for host and -O3 for
device. This replaces the logic in the CI script that had to touch
`CMAKE_CXX_FLAGS` and `CUDA_NVCC_FLAGS`. The -O0 optimization flag
for host avoids ending up with source code lines in the gcov output
with neither hit or miss. According to `man gcov`:

> compile your code without optimization if you plan to use gcov
> because the optimization, by combining some lines of code into
> one function, may not give you as much information as you need

Generate a warning for incorrect build types and override them with
'Release'. Move the `set(CMAKE_BUILD_TYPE CACHE)` declaration out
of the conditional such that its help message always gets displayed
in cmake/ccmake. List the possible values as properties to allow
cycling in ccmake and cmake-gui (instead of manually typing them).
Same thing for WITH_CUDA_COMPILER. This is achieved by creating a
wrapper around the `option()` function that accepts an enum value
(stored as a string) instead of a boolean value.

The same guard is used in the CMake logic for Python tests.

The "release with assertions" build type restores the original
behavior of the CI pipeline for non-coverage CI jobs: -O3 for
faster tests and -g to get a minimal backtrace in GDB.

The original `build_cmake.sh` logic was accidentally compiling
ESPResSo with optimization flag -O0 in job "installation", leading
to a significant slowdown in CI.

Move all the if/else logic for CMake options above the function call
that prints shell variables to display the full CMake command in CI.

Use interface libraries for compiler flags instead of populating
variable with global scope that are injected in the compilation and
linking commands of all libraries (e.g. CMAKE_CXX_FLAGS). Remove
duplicated compile flags. Give meaningful names to variables in
FindCUDA* CMake files. Document CMake policies and add CMP0025 to
distinguish between Clang and AppleClang. Replace simple if/else
blocks by generator expressions.

Move ROCm path patching logic in FindCUDACompilerHIP.cmake and
check only the HIP version.

The double quotes were not removed by the shell interpreter.

Clang returns "version unknown" for unsupported CUDA libraries,
or doesn't return a version string (depending on CMAKE_CXX_FLAGS),
causing the CMake regex to store the complete Clang stdout in the
CUDA_VERSION variable instead of a valid version number. This is
now fixed, and the CUDA version is now shown as <major>.<minor>.