Class-based transforms

``base.transform.Registry.register()`` already wraps a transform
function in a class.  However, after implementing a number of
somewhat complex transforms for Maryland, it became clear that
transforms should be able to be implemented as either a function
or a class.

I broke the function-wrapping behavior out of
``base.transform.Transform`` into a separate class,
``base.transform.FunctionWrappingTransform``.

I also added a ``reverse()`` method to ``Transform`` as an API hook
to undo the results of the transform.  This can't be accessed via
the invoke task, but it might make sense to do do that eventually.
The main motivation for implementing a ``reverse()`` method was
because the result-creating transforms already had this behavior
and I was factoring it out into a class method anyway.

I removed the ``validators`` argument from ``Transform.__init__()``
as it wasn't actually getting used, with the ``add_validators()``
method being the preferred way of binding validators to a
transform instance.

I refactored the Maryland transforms into class-based transforms.
It didn't neccesarily result in less code, but it did make it
much clearer which methods were utility methods and which methods
were related to a particular transform.  I was able to make the
code more DRY for the result creating transforms.

Addresses #92