foamgrid-test.cc and local-refine-test.cc are expected to fail with

```
Dune::GridError [checkIntersectionIterator:[...]/dune/grid/test/checkintersectionit.hh:600]:
Integral over outer normals on affine entity is nonzero: -1 0 0
```

The test from dune-grid doesn't quite apply to FoamGrid and needs to
be adapted to make the tests pass.

Communicate seems to be required by DefaultGridView.
Throw an exception in loadBalance when the number of processes is greater than 1.

This called the forward iterator test two fail because two default constructed
intersectioniterators didn't compare equal. Now that all members are properly
initialized the test passes again.

We also need to know which indices a vertex had at insertion in case we need to
attach data to a vertex during growth. This was already implemented for elements,
but is necessary for vertices too.

I do not use the DGF format, but users having to include the
implementation in `dgffoam.cc` looks wrong.

The file was removed in a3cdfb27

Id sets have to provide unique ids for all entitites of a grid.
In Foamgrid the id was only unique within the subset of entities
of the same codimension.

integer types in interface cleaned up, to reduce warnings related to comparison between signed and unsigned integers

The previous test refined all elements using local adaptivity. The new
test results in a leaf view with elements of different levels and tests
more things. The bug fixed in 6e374b7d
would have been revealed.

The previous implementation had a sign mistake and thus only worked
for intersections connecting elements on the same level. The new
implementation works for adaptive grids as well.

Note: this is a backward compatible change. The growth insertion index
can now be used conveniently to attach user data to the new element.

Each element has a growthInsertionIndex that can be queried using a grid method
with the same name. This index is only valid between calling grow() and postGrow()
and only for elements that have been inserted using the grids insertElement method.
It can be used to attach user data to an element inserted with the insertElement method,
because we don't know at insertion time (before calling grow()) which index or id
the element will have in the grid. The concept is very similar to the insertionIndex
of the factory with the difference that the validity of the index is only temporary.

When inserting two element that share a new vertex this vertex was inserted twice
resulting in a disconnected grid. The check if a vertex is already inserted was
already in place, however the map had the wrong scope and the pointer written
in the map was a pointer to the grid entity not the entity in the to-be-inserted queue.

This silences a few warnings when compiling with -DNDEBUG.

When global refining not all isNew markers were removed.
This also caused a bug when mixing growth and adaptivity as the
isNew marker is also used for newly added elements through growth.