add support for vectorization library Vc

This branch adds support for the Vc library, which add support for vectorization, including an abstraction for intrisics.

We have been using in EXA-Dune and I belive that the integration of vectorization support into the core-Dune is something Dune in general can benefit from. A separate branch I'm preparing for ISTL will add support for multiple RHS vectors using vectorization.

The branch collects a set of helper classes which allow to add vectorization support to your code with moderate effort. Mainly this means that we have a couple of utility functions, which work for scalar data types, ranges and SIMD data types alike.

See also: !16, dune-istl!17, dune-geometry!13.

**Note**: This is the followup merge request to !16.  The original was merged accidentially and had to be reverted, see #26.  The branch had to be rebased; if you had checked out an earlier version of feature/vc you may need to take special action to rebase onto the new branch.#


See merge request !81

[doc] minor corrections



See merge request !114

[hybridutilitiestest] Don't make function constexpr const

constexpr implies const

See merge request !112

constexpr implies const

[whitespace] Disallow trailing whitespace and tabs-in-indent in shell and python files

More whitespace checks are always better...

See merge request !110

Add .gitlab-ci.yml



See merge request !111

This helps the compiler that may fail to determine the value
on its own.

Accessing ::value fails with clang for reference types.

As noted by Elias Pipping, this does compile with clang-3.8
if we have a reference type.

Introduce hybrid utilities for homogeneous and heterogeneous containers

These utilities are hybrid in the sense that they work
* classical and heterogeneous containers
* dynamical intergers and `integral_constant`s

As a rule of thumb, size and indices are encoded as integral_constant
if possible. This allows to write code like
```c++
  forEach(integralRange(size(v)), [&](auto i){
    elementAt(v, i) = i+1;
  });
```
which will e.g. work for `std::vector`, `Dune::BlockVector`
but also `std::tuple` and `Dune::MultiTypeBlockVector`.
Another feature is `ifElse` which provides a hybrid conditional.
If passed `std::true_type` or `std::false_type` instead of bool
this emulates a `static_if`.

See merge request !103

In C++14 constexpr does not imply const in contrast to C++11.
Since this is not implemented in gcc-4.9 you cannot have
a non-const constexpr function. Hence we need a non-constexpr
operator[] if we want a non-const one.

Notice that the const of the constexpr version is not needed
in gcc-4.9 but in newer versions implementing this correctly.

We could cast the std::initializer_list to void to avoid the
warning. But extracting this as a function makes the code more
readable.

Maybe evaluateFoldExpression() should be moved outside of Imp::
because this little trick nicely helps to avoid a template recursion
and may help to simplify other places, too.

Maybe they will be reintroduced, once the return iterator-like things.
For now they are not used anyway.

If T1 and T2 are not defined by 'const T1&', they will themselves
be of reference type. Hence T2::value does not exist and the
equals() overload for the static evaluation is not selected.
Then the dynamic equals() overload is used. This will give the
same result, but the compiler will instantiate the if branch
with the identity if the result is 'false'.

This could be fixed using std::decay_t. But since comparison
should be a const operation anyway, using a const reference
is cleaner here.

This helps finding these functions in the docs.

These functions are hybrid in the sense that they work
* classical and heterogeneous containers
* dynamical intergers and integral_constants

As a rule of thumb, size and indices are encoded as integral_constant
if possible. This allows to write code like

  forEach(integralRange(size(v)), [&](auto i){
    elementAt(v, i) = i+1;
  });

which will e.g. work for std::vector, Dune::BlockVector
but also std::tuple and Dune::MultiTypeBlockVector.

Another feature is ifElse which provides a hybrid conditional.
If passed std::true_type or std::false_type instead of bool
this emulates a static_if.