* Changes to block preconditioning

** Removed Nmesh variable from BlockPreconditioner class
   For some reason the size of the vector Mesh_pt was stored in a seperate class
   variable as well as in Mesh_pt.size().

   I removed the extra variable, replaced all references to it with an access
   function to Mesh_pt.size() and changed set_nmesh(...) to resize Mesh_pt.

** Moved calculations out of set_mesh(..)
   The set mesh function used to also calculate the number of dofs in the mesh
   and check for consistency over multiple processors. This caused issues if you
   tried to add mesh pointers to the vector before finishing building the
   mesh. Also it seems strange to have a calculation about the mesh done in a
   member function for a specific type of preconditioner instead of in the Mesh
   class.

   I moved the calculations to a new function ndof_types(...) in the Mesh class.
   The function is called for each mesh_pt at the start of block_setup and the
   result stored, as before. If the number of dof types in a mesh is requested
   before block_setup(...) has been called then Mesh::ndof_types(...) is used to
   get the value.

** Stored Matrix_pt in the BlockPreconditioner class
   A matrix pointer was passed around various functions within the
   BlockPreconditioner but it makes no sense to set up a blocking scheme for one
   matrix then to try to apply it to a different matrix.

   I added Matrix_pt as a class variable (with set and access functions). I
   changed get_block(...), get_blocks(...) and block_matrix_test(...) to use this
   class variable rather than requiring an input. I also created wrapper
   functions taking the same arguments as previously so as not to break
   compatability.

** Made use of the Problem_pt class member variable
   Some functions required a problem pointer as an argument even though the
   block preconditioner is set up for a specific problem (similar to the
   previous change).

   I added set and access functions for the Problem_pt variable and changed the
   set_mesh(...), block_setup(...), get_block(...), get_blocks(...) and
   block_matrix_test(...) functions to make of use them. I also wrote
   compatability wrappers so that the old style of functions can be used.

   In preconditioners deriving from BlockPreconditioner Problem_pt should now be
   assigned in the preconditioner setup(...) function.

** Changed function arguments to use MATRIX* instead of DenseDoubleMatrix*
   We know the matrix type is MATRIX (from the template) so it makes sense to be
   more specific and consistent.

** Changed all GeneralPurposeBlockPreconditioners to use the new functions
   Changed some function arguments.

   Dynamic cast matrix pointers in preconditioner_solve(...) before passing to
   block_setup(...).

** Smaller changes
   Added initialisation setting pointers to null in constructor.

   Changed Mesh_pt from Vector<Mesh*> to Vector<const Mesh*> (not allowed to
   change the mesh via the preconditioner.

   Fixed some comments - grammar, miss-copied sentences, text wrapping etc.

   Removed unnecessary if statements from is_subsidiary_block_preconditioner(),
   is_master_block_preconditioner().

   Changed from using variables directly to using access functions where it
   makes the code clearer.

   Added (class) const to some access functions, get_block... functions and
   return_block... functions.

   Added const access function to element_pt via mesh.

   Added some timers to GeneralPurposeBlockPreconditioners.

   Added an access function to newton_solver_tolerance in Problem.

** Testing
   Self tests: demo_drivers/linear_solvers - all passed.

   My preconditioner_test_driver - all general purpose preconditioners passed.

** Possible future work
   Change demo drivers/tutorials to specify that different elements should be in
   different meshes unless there is a good reason not.

   Test with Ray's code, other preconditioners.

   Write general purpose output functions for the blocked Jacobian and the
   (solved) preconditioner.