Adding first sketch at boundary operator wrappers (#132)

Wrapping the BoundaryOperator class. The memory where instances of the class
are constructed is owned by C++. It is the largest possible size of all
possible `BoundaryOperator<basis_type, result_type>` instances.
The operators are then constructed in-place according to the basis and result
type in the __init__ method.
Member method wrappers should first look to result_type and basis_type to
figure out how to cast the memory to right instance.
Moved file out of mako since not needed
Deconstruction of boundary operator

If construction was successful, the boundary operators are now explicitly
deconstructed.
Convenience functions to access sample grids
Constructing options with incompatible basis and result type fails

It wasn't so clear before that. The construction could go through despite the
arguments being incompatible.
Simplifying check for basis and result type compatibility at construction

Boundary operator now relies on the check from Options.
Adding context and boundary operators

Currently implementing only boundary operators from dirichlet tutorial.
Context directly accessible under bempp namespace
Making grids constant

Currently can't modify grids from python, so might as well be constant.
Later on, we may have to add both and check whether the C bit is constant or
not.
Grid that space refers to obtain from C++

This grid is constant.
operators in context are now a hierarchy of modules

This should make it possible to add docstrings to the modules, as needed. And
it should make it possible to look at the docstrings of the operator factories.
Grid hierarchy is Cython wrapped. Some methods still need to be implemented.
Merged operator branch and fixed pointer issues in entity and geometry class
Sample grid disappeared somehow. Now reinstated.

Moved __init__.mako.py back to __init__.py since no mako stuff used.
Corrected CMakeLists.txt accordingly.
Pointer fixes in grid class
Spaces are wrapped via a boost::variant

This approach seems to be somewhat simpler. It should also make it easier to
wrap shared_ptr[T] and shared_ptr[const T] instances without sacrificing const
correctness.

Added some functionality to Space wrappers to showcase new variant
implementation.
Python 3 patches. Should now work in Python 2 and 3
Add template type as trait to Space
Re-implement Boundary operator wrapper

Now uses a boost::variant. This is a safer way to deal with the multiple types
that (with respect to basis and result type) the operators can have. Basically,
static polymorphism is dealt with at the C++ level, rather than via casting in
cython. Compiling is slower (template instantiation), but compute should be
quite similar, if not faster.
Add comparison operator to spaces