This introduces a helper function that enables `auto` type deduction even in
the presence of proxies and pre-C++11 libraries with a tendency to capture
references to temporaries.

Note: the motivating examples below make use of specializations of
      `autoCopy()` that will be introduced in later commits.

Example 1: deducing the element type of a vector when proxies are a
possibility:
```c++
template<class Vector>
auto pop_and_clear(Vector &v)
{
  auto head = autoCopy(v[0]);
  v.clear();
  return head;
}
```
Without `autoCopy()` this would be undefined behaviour if `Vector` happens to
be `std::vector<bool>`.

Example 2: a custom number type with lazy evaluation:
```c++
template<class MaybeCustomType>
auto f(MaybeCustomType v)
{
  return 2 * v - 1;
}
```
This fails for the custom number type from the automatic differentiation
library Adept, because Adept constructs an expression object that holds
references to its subexpressions and is evaluated only when it is assigned to
a number object later.  Due to the use of `auto` this expression object is
passed out of the function, but the temporary object for the subexpression
`2*v` is destroyed when the function returns.  Wrapping the expression in the
`return` statement with `autoCopy()` ensures that the evaluation happens while
the reference to the subexpression is still valid, and has no ill effect when
fundamental types instead of Adept's custom types are used.

[Vc] Deal with the missing swap() on Vc proxies.

Closes #59

See merge request !339

This is needed to pull in the fix for #88.

[Vc] Work around missing std::for_each_n() in g++ 7.2.

Closes #88

See merge request !341

`Vc/common/algorithm.hh` uses `std::for_each_n()` when it detects C++17, but
g++ 7.2 does not seem to provide it (yet).  Work around this by disabling the
macro that signals C++17-support in Vc.

Closes: #88.

This is a problem with Vc 1.3.0.  Vc 1.3.2 seems to have implemented
`swap()`.

We work around it using copying and a temporary to implement `swap()` on our
own wrapping proxies.  Any member type of a Vc SIMD type should be a
fundamental type, so we don't bother using moves.

Closes: #59.

Deal with Vc access proxies

Closes #59

See merge request !338

This is needed by the `luDecomposition()` in densematrix.hh

This is needed because newer versions of Vc introduce their own proxies as the
result of expression like `v[0]`.  These proxies cannot be constructed outside
of Vc, not even by copying or moving, so we cannot pass them out of our
`lane()` function.  We work around this by introducing our own proxy class,
that we can copy.

That proxy class was originally introduced for !193 (Proper SIMD Interface)
and has been backported for the 2.6 Dune release.

Closes: #59

bump version to 2.7-git [ci skip]

See merge request core/dune-common!337

parallel index sets: correct typo; return value of AllSet::contains() [ci skip]

See merge request core/dune-common!335

Fix module name for dunecontrol update

Closes #78

See merge request core/dune-common!332

Fix status message

See merge request core/dune-common!331

When dunecontrol update fails the module name no longer has
underscores instead of hyphens.

This fixes #78

We are not 'running' the doxygen documentation,
we are building it.

Replace throw by terminate in destructor

See merge request core/dune-common!327

re-enable transformTuple test fails with debian 8 gcc

See merge request core/dune-common!273

added a range function for range based for loops over consecutive integers

See merge request core/dune-common!325

[std] add fallback implementation for std::conjunction / std::disjunction

See merge request core/dune-common!322

Disbable a deprecation warning in a test

See merge request core/dune-common!328

Since the destructor is no longer noexcept(false) it
will never throw an exception to its caller but always
call std::terminate().

In C++11 destructors are implcity `noexcept` such
that a `throw` leads to a call of `std::terminate()`
anyway. Hence this commit does not change the behaviour
but only avoids a warning.

BTW: Destructors are `noexcept` for good reason, because
it is in general very hard to recover from a failing destructor.
This also applies here.

Require GCC 5 and C++14

See merge request core/dune-common!320

Feature/require cmake 3.1

See merge request core/dune-common!323

[bugfix] Correctly display headercheck status message

Closes #86

See merge request !326

Surprisingly, the -D and -P arguments to cmake are required in a specific order:
D before P!

implement optional similarly to the one propoed in C++14 draft N3690

See merge request !276

[cleanup] fix some typos

See merge request !321