Support Constant in firedrake par_loop

Allow passing a Constant in to a par_loop (always accessed with single
indirection).  For example, to assign a function to the minimum of
itself and some specified constant:

   c = Constant(100)
   f = Function(V)

   par_loop('for(int i = 0; i < f.ndof; i++) { f[i][0] = fmin(f[i][0], c[0]); }',
            dx, {'f': (f, RW), 'c': (c, READ)})
Update par_loop documentation for new Constant type
Store permutation from new to original cell numbering

We need this to back out the correct coarse to fine cell maps in a mesh
hierarchy.
Add optional distribute flag to mesh creation

If distribute is False, the mesh is already distributed and we should
not do so again.
Ensure meshes always have name
Add multigrid module

Contains basic Mesh, FunctionSpace and Function hierarchies that are
containers for a bag of nested meshes and associated function spaces and
functions.
Use DMPlex refinement to build refined sphere mesh

Rather than walking cell by cell in python, let PETSc refine the base
icosahedron and then fix up the coordinates in one go using a numpy
splat.
Add restriction and prolongation methods to FunctionHierarchy

Only implemented for DG0 for now.
Add reorder argument to MeshHierarchy
Pass geometric dimension to Mesh constructor when refining

The plex doesn't know this information, so explicitly provide it.
Stash a vertex numbering on the mesh
Build unique cell_node_maps for coarse cells to fine nodes

We build a map from each coarse cell to the fine degrees of freedom one
the fine cells the coarse cell spans.  Since the meshes are nested,
these come out in a predictable order each time, such that we can write
kernels that map between the two simply.
Implement fast determination of old_to_new cell maps

We need these to back out the coarse cell to fine dof maps in the
multigrid hierarchy.  So implement in Cython and only build on demand in
MeshHierarchy construction.
Rework get_cell_renumbering to get_entity_renumbering

We need the vertex permutation too.
Implement fast derivation of P1 coarse cell to fine dof map

The map from coarse cells to fine dofs is isomorphic to the P2 map on
the coarse mesh.  This is significantly faster than the previous pure
python implementation, taking less than half a second to build a map
from 1280000 coarse cells to 2563201 fine dofs (in comparison, building
the coarse mesh in that case takes around 20 seconds).
dmplex: Annotate all numpy array declarations with ndim and mode="c"

Makes indexed access marginally faster since we don't go through
"strided" array accessors any more (but rather C-contiguous ones).
Implement prolongation of P1 fields on triangles
Implement restriction of P1 fields on triangles

We restrict by computing a lumped projection of the fine field to the
coarse space.  To do this, we exploit that when the coarse cell is
pulled back to the reference cell, the fine cells always look the
same (since the refinement is uniform).  As a result, we can precompute
the coarse cell basis functions tabulated at the fine cell integration
points and then run over the mesh computing the RHS for the lumped
projection (u_f*phi_c*dx).
Implement injection of P1 fields on triangles
Add multiplication by detJ in residual restriction

We need to weight the restricted residual by a factor of the size of the
big cell relative to the small ones.  This is basically just 2**tdim.