[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).
[REWRITE] Yasp has all entities and communication.

This is a major rewrite of Dune::YaspGrid. It now
- has full entities of all codimensions
- communicates on all these codimensions
- works for arbitrary dimension (again)

Of course, these new features come at a price.
The performance implications in comparison to the old
code have been measured. Iterating over the grid and
computing indices and subindices got a bit slower
(to a maximum of 20%). However, these operations are
still really (!) fast.

Here are some implications for the implementation
(not of interest for users):
- The former YGrid is now called YGridComponent. All entities
  that belong to one such component share the same "shift"
  (the set of spanning unity vectors). For codim 0 and dim,
  there was only one component describing a codimension, in
  general this is dim choose codim.
- A YGrid is a collection of YGridComponent. A YGrid
  describes the parts of a grid given by partition type
  and a codimension. It offers iterators to iterate over
  the multiple components. YGridList does the same thing
  for send and receive lists.
- Yasp handles codimensions generically now. The former
  data structures {cell,vertex}_{...} are replaced by
  arrays of size dim + 1 of {...}.
- The entity implementation provides a generic implementation
  of the index methods according to the new generic reference
  elements.
- A namespace Yasp is introduced and used to hide away some
  free functions from the user.
- YaspGeometry now handles the bitsets required by
  AxisAlignedCubeGeometry directly.

The incode and doxygen documentation of the rewritten code
was improved whenever it seemed necessary.
[bugfix,documentation] Fix spelling in comment
[bugfix] fix initializer list of unused constructor

This constructor was not covered by the test and was forgotten.
Treat geometries by its lower left and upper right corner

Yasp treated geometries by taking the midpoint and size information,
although it stored the information as lower left and upper right
corner. AxisAlignedCubeGeometry also asks for the latter. With this
patch, this transformation is omitted. Additionally, YgridComponent::
Iterator doesnt store positions anymore but instead asks the coordinate
container directly.
[doc] Document that YaspGeometry and AxisAlignedCubeGeometry are the same now.
Implement VTKSequenceWriterBase without the Curiously Recurring Template Pattern

... and without multiple inheritance.  It is simpler that way, and not less
efficient.
Fix copy'n'paste error in documentation
[bugfix] Fix valgrind bug on tensorproduct grids

The recent change in the instersection resulted in invalid
reads on the tensorproduct coordinate container. The intersection
now asks the container directly, instead of using the outside
entity. Additionally, the upperright() method of the YGridComponent
doesnt use the meshsize anymore but instead looks up the correct
coordinate.
[yaspgrid, bugfix] fix assignment from variable to itself
[bugfix,documentation] Fix spelling in comment
[dune.module] Next dune version will be 2.4 not 3.0.
[Iterator] make Iterator a forward iterator

as decided on the 2014 meeting the Level- & LeafIterator should be
compatible with the forward iterator concept. This means in particular
that we have to add default constructor and post-increment operator.
This patch implements the post-increment in the facades class. The
default constructor is added to the facades class, but it clearly
requires changes to the imeplementations.
[test] add forward iterator check to the iterator test
[iterator] add iterator tag to the leaf/level iterator
[test,bugfix] fix call to forward iterator test
[iterator] we specialize the iterator traits, thus we don't have to inherit std::iterator