[Interface] Only provide const access to entity in EntityPointer

I was a little surprised to learn that the EntityPointer facade gives
non-const access to the stored Entity...

I really don't think that was intended, or was it? Anyway, this patch
enforces the constness.
[Interface] Make entities copyable and movable

This patch adds public copy and move constructors as well as copy and
move assignment operators to the Entity facades.

WARNING: Grids that do not support copying / moving entities yet *MUST*
delete the corresponding methods on their entity implementations;
otherwise people can start copying entities of those grids, which will
probably lead to horrible crashes.

Moreover, this patch also adds comparison operators for equality and
inequality. Grid implementors might have to provide appropriate versions
of operator== and operator!= as well, depending on the internal layout
of the entity implementations.
[Interface] Make intersections copyable and movable

This patch adds public copy and move constructors as well as copy and
move assignment operators to the Intersection facade.

WARNING: Grids that do not support copying / moving intersections yet *MUST*
delete the corresponding methods on their entity implementations;
otherwise people can start copying intersections of those grids, which will
probably lead to horrible crashes.

Moreover, this patch also adds comparison operators for equality and
inequality. Grid implementors might have to provide appropriate versions
of operator== and operator!= as well, depending on the internal layout
of the intersection implementations.
[YaspGrid] Make YaspGrid entities copyable and movable

With this patch, it becomes possible to copy, move and store YaspGrid
entities.

The old entity implementation relies on an EntityPointer to provide
storage for the data required by the entity; the entity then simply
contains pointers to this data. In particular, an entity object contains
a pointer to the containing grid as well as pointers to two objects
currently stored in the EntityPointer:

- an iterator that provides access to the grid level
- the actual YGrid iterator that is used to iterate over the entities

In order to make the entity independent of its underlying
EntityPointer, this patch moves those two objects into the entity itself
(with the nice side effect of improving readability of the code, as
those pointers don't have to be derefenced all the time anymore).

The EntityPointer now only contains an entity object. Note that in
contrast to the old implementation, it actually contains the full facade
object instead of the implementation object. That way, we don't have to
construct a temporary every time the iterator is dereferenced, which
also used to force a copy of the implementation object. That copy has
just gotten more expensive (all the data now lives inside the entity),
so it's a good idea to avoid the copy.

We can also get rid of all the custom copy code for the EntityPointer,
as the autogenerated ones will now do the right thing for the shiny new
entity stored inside the EntityPointer.

Finally, we have to modify both the LevelIterator and the
HierarchicIterator, which used to operate on the data members of the
EntityPointer base class. As those members are now stored directly
inside the entity, the iterators need access to the entity
implementation, so they had to become friends of both the grid (so they
can use Grid::getRealImplementation()) and the entity.
[YaspGrid] Make YaspGrid intersections copyable and movable

With this patch, it becomes possible to copy, move and store YaspGrid
intersections.

This requires less changes than the entities because all required data
is already stored inside the intersection object. So the patch

- Removes all of the custom copy code and just rely on the autogenerated
  functions.

- Changes the IntersectionIterator to contain a complete interface
  intersection object. This avoids creating a temporary every time the
  iterator is dereferenced. On the other hand, we now have to use
  Grid::getRealImplementation() to access the intersection
  implementation from the iterator.

- Changes the time at which the internal state of the intersection is
  made consistent. The intersection contains a method update(), which
  updates the YGrid iterator for the outside cell and the face
  information. This method used to be called in various intersection
  methods which required this information to be up to date. With this
  patch, update() is now called when dereferencing the iterator, which
  allows us to get rid of all the mutable data members inside the
  intersection.
[YaspGrid][Performance] Fix intersection performance regression

When using a range-based for loop to iterate over intersections,
YaspGrid exhibits a very bad performance regression compared to the
old-style approach with explicit iterators. After some digging around,
I still don't fully understand the problem, but I have a fix:

The problem is in some way related to the two iterator movements for the
outside entity in the update() method.

Currently, the YGrid iterator can only be moved by an arbitrary offset
in a single direction. This patch adds a new method that takes a vector
of per-direction offset. The update method then calculates the overall
movement vector that results from the original two movements and then
performs that single movement.

That change fixes the regression, but unfortunately I have no idea
why...

As calling update() is now almost a lot cheaper, I also removed the
check to avoid moving the entity twice - that check actually slows down
the common case of only dereferencing the iterator once per
intersections for me because my compiler / CPU combination does a bad
job of predicting that branch correctly.
Merge branch 'feature/FS1511-copyable-entities-for-yaspgrid'

This branch modifies the grid interface to allow copying and moving of
entities and intersections as decided in Berlin (including the
refinements decided in Doodles 19 and 20).

it also implements the new behavior for YaspGrid and while at it, I
fixed a nasty performance regression that occured when iterating over
YaspGrid intersections.

See FS#1511 for the accompanying discussion.

* feature/FS1511-copyable-entities-for-yaspgrid:
  [YaspGrid][Performance] Fix intersection performance regression
  [YaspGrid] Make YaspGrid intersections copyable and movable
  [YaspGrid] Make YaspGrid entities copyable and movable
  [Interface] Make intersections copyable and movable
  [Interface] Make entities copyable and movable
  [Interface] Only provide const access to entity in EntityPointer