[CI] Remove the variable DUNE_RUNNING_IN_CI from the local gitlab-ci

See merge request !1488

Fix/cmake module path

See merge request !1486

Remove the variable DUNE_RUNNING_IN_CI from the local gitlab-ci, since already set in the docker image

[ci] Make .gitlab-ci.yml portable

See merge request !1482

Deprecate the MODULE_LIBRARIES argument to dune_enable_all_packages

Closes #387

See merge request !1475

Do not inherit global variables in a triggered pipeline

See merge request !1487

Currently the CI config requires that the `core/ci-config`
project exists on the same gitlab server. This prevents
the CI from working when pushing the repository to another
server. While one may argue, that one also has to push
`core/ci-config` then, it is a very strong restriction to
require that the gitlab group `core` is available.

This can be avoided by using a gitlab remote include for those
files with a link pointing to the dune server instead of a local
include.

Improve the error message in the DenseMatrixAssigner for DiagonalMatrix

See merge request !1480

Link all targets in a directory against Dune::Common

See merge request !1481

Deactivate transposetest for DiagonalMatrix

See merge request !1478

Use targets in duneproject

See merge request !1460

[bugfix] Don't implent operator<< templated wrt the stream

See merge request !1476

When implementing `operator<<(S& , const T&)` to provide character
stream support for a custom type `T`, the overload should be specific
to `S=std::ostream` and not be templated wrt `S`. Otherwise this may
lead to ambiguous overloads downstream.
To give two examples for problematic cases:

Here we defined an overload
```cpp
template<class Stream, class T, std::size_t N>
inline Stream& operator<<(Stream&, const std::array<T,N>&)
```
If a downstream module wants to defines an overload
```cpp
template<class A>
inline std::ostream& operator<<(std::ostream&, const A&)
```
for a custom type `A` derived from `std::array<T,N>`,
this leads to ambiguity.

If a custom class `S` that does not represent a character stream
wants to use the `s << t` syntax in anoter context, this cannot
be done for cases where `t` is an `std::array`. Furtermore
the overload that we provide here may in general not make any
sense in this context.

BTW: One may argue that defining overloads for `std::` types
is in general a very bad idea. Imagine that another library
does the same - then we cannot use it together with dune, because
both claim to be the authority over `std::`.

Fix wrong variable name to make target hash

See merge request !1469

Add precompiled code into the python module in the expensive test

See merge request !1465

Update template project to use targets and use more modern CMake

Add missing includes in python/tuplevector

See merge request !1466

Improve the documentation of the dune policy DP_DEFAULT_INCLUDE_DIRS

See merge request !1462