[GridView] Add support for using range-based for loops on GridView

These changes make it possible to use the C++11 range-based for
loop to iterate over entities in a GridView given either
dimension or codimension:

 using Dune::Codim;
 using Dune::Dim;
 for (auto& face : entities(gridview, Codim<1>())) { ... }
 for (auto& vertex : entities(gridview, Dim<0>())) { ... }

For common cases a bit nicer syntax is also available:

 for (auto& e : elements(gridview)) { ... }
 for (auto& f : faces(gridview)) { ... }
 for (auto& e : edges(gridview)) { ... }
 for (auto& v : vertices(gridview)) { ... }

It is not necessary for users to qualify the functions with the
Dune namespace as they are found using argument-dependent lookup.

This patch requires accompanying changes in dune-common (the
IteratorRange class) and dune-geometry (Dune::Dim and Dune::Codim).
[Entity] Add support for using range-based for hierarchic entity iterators

These changes make it possible to use the C++11 range-based for
loop to iterate over the child elements of a codimension 0 entity
by simply writing

 for (auto& e : childElements(element,maxLevel)) { ... }

This patch requires accompanying changes in dune-common (the
IteratorRange class) and dune-geometry (Dune::Dim and Dune::Codim).
[Tests] Add test for new iterator ranges
[Iterator Ranges] Rename some functions for clarity

Rename faces(gv) -> facets(gv) and
childElements(entity,maxLevel) -> descendantElements(entity,maxLevel)
as suggested by Carsten in FS1042. The new names more clearly convey
the meaning of those iterator ranges (see comments in FS1042).
[Common] Add PartitionSet class that provides a static wrapper for sets of PartitionTypes

In order to provide entity ranges for different PartitionIteratorTypes,
we need a class that captures a set of partitions in a type signature.

The new class PartitionSet does exactly that and also allows for
combining and subtracting such sets. It is also possible to statically
extract the PartitionIteratorType value that corresponds to the stored
set of partitions.

Finally, it adds a set of default PartitionSets to the namespace
Dune::Partitions. Those instances are placed in an anonymous namespace
to avoid linking problems and cover all of the current PartitionType
values and their iterable combinations.
[Documentation] Add parallel partition enums to new Doxygen documentation group containing PartitionSet
[EntityRanges] Clean up entity range generation functions and add support for user-selectable partition types

This patch adopts the changes discussed at the developer meeting:

- Add support for user-selected partition types. This is based on the
  new PartitionSet.

- Make sure all implementations fall back on the single canonical
  version for a codim and a user-provided partition type. Forwarding is
  achieved using C++ type forwarding in the remaining functions.

- All implementations that do not provide a partition type forward to
  the version based on a codim, but no partition type first. That should
  make it easier to reuse the infrastructure for user-provided GridViews
  that do not support partition types.

- intersections() now takes the GridView first and the Entity second.

- Moved all code to the new header entityrangegenerators.hh.

- Split out Doxygen pseudo-declarations and actual implementations to
  improve documentation readability.
[PartitionSet] Add query function to test whether PartitionType is contained in the set

This patch adds a new method contains() to the PartitionSet. It can be
used to test whether a given PartitionType is contained in the set.

The method is constexpr if available to allow future usage in TMPs.
[Documentation] Document range-based for helpers

This patch adds a whole bunch of documentation for the new helper
functions that enable iteration over entities and intersections using
range-based for.

There is a general introduction to the concept and detailed
documentation for each of the functions. The functions are also listed
as related to the GridView, so they also appear on that documentation
page.

The functions are added to a new subgroup of the grid interface group.
[Documentation] Move PartitionSet docu to grid interface

The PartitionSet is a related type of the grid, so it should be in the
Doxygen group GIRelatedTypes. Unfortunately, that group is labelled
Enumerations, so expand that label a bit.
Merge branch 'master' into feature/FS1042-range-based-for-infrastructure

* master: (60 commits)
  Deprecated the file sgrid.hh
  [geometrygrid] make iterators default constructible
  Revert "Implement VTKSequenceWriterBase without the Curiously Recurring Template Pattern"
  entitypointer.hh: fix a few typos in the documentation
  [interface] deprecate template versions of leafGridView / levelGridView
  [cleanup] remove methods leafView / levelView from grid
  [test] don't ask for grid views with specified partition iterator type
  [CMake] Improve handling of experimental grid extension flag.
  [cleanup] Remove the load balancing parameter from some methods.
  [Warning] Switch to std::ostringstream
  [bugfix] Use user-provided load balancer
  [cleanup] Remove some boiler-plate code
  Use the index type exported from the mapper, rather than expecting 'int'
  Use IndexSet::IndexType as the type for indices, rather than hardwiring 'int'
  Make the index type a configurable template parameter
  [documentation] Use \tparam to document template parameters
  Canonicalize single-inclusion guards
  [cleanup] Remove spurious marker from old version control system
  [yaspgrid,bugfix] we actually have to use references or pointers in the entity.
  [yaspgrid] make yaspgrid iterators default constructable
  ...
[Ranges] Move hierachic descendantElements() to new header file

Whoops, completely forgot about that one...
[PartitionSet] Clean up compile time errors

I moved a number of functions into the PartitionSet class, which created
some problems with missing consts and template parameters.

Fixed.
[Ranges] Rename entityrangegenerators.hh -> rangegenerators.hh

The file also contains the intersection range (and will maybe contain
even more different ranges later on), so remove the entity qualifier.
[Ranges] Include rangegenerators.hh in entity.hh

The descendantElements() function is mostly related to the Entity, so
make sure it is available when including entity.hh.
[Ranges] Add some useful documentation for grid implementors
[Ranges] Make range generator functions inline
[Ranges] Add unit test for entity and intersection ranges

There are two versions of the test, one that uses range-based for loops
and a fallback with an explicitly coded iterator-based loop that can be
used on older compilers.

The tests are designed to catch the following errors:

- Returning the wrong type (codimension) of entities
- Returning the wrong number of entities

The tests also supports running in parallel.
[Ranges] Make ranges only available if range-based loops are supported

Originally, this patch set tried to make the range generating functions
available to all supported compilers, as they might be useful even
without range-based for loops. Unfortunately, GCC 4.4 has a serious
compiler bug that makes it impossible to backport the
functionality. Instead of introducing an additional check that would
make the functions available on GCC 4.5, this patch simply hardcodes
range-based for loops as a requirement.

The docs have been adjusted accordingly and now state that GCC 4.6 is
required for the range generating functions.
[Ranges][Tests] Clean up test for iteration ranges and remove fallback support

This patch separates the actual tests from the grid creation process,
making it easier to perhaps extract those tests later on if people want
to run them on their own grids.

It also removes the fallback code for compilers without range-based for
loops as well as the backwards compatibility binary that was built to
test the fallback code on newer compilers.