First pass at registration-based serialization

Pretty low overhead, and no requirement for special base classes.  The
most basic use-case with no type conversion requires adding the
@autoserialized decorator, and a serial_format string.

Further improvements can include better registration, and out-of-order
registration (keeping a mapping of unresolved references).  In this way,
Tile could be registered before Color.
Add helpers for nested attributes

getattrpath is for nested retrieval (getting obj.a.b.c with
getattrpath(obj, 'a.b.c))

prefix_keys generates key, value pairs with the prefix prepended to each
key.
Refactor registration, swapped format ordering

name=format instead of format=name

improved how to index into class serialization metadata
Move str_func to util, code cleanup
Added repr_func util
tests use repr_func and new converters

converters are in the next commit, but are a way to interact with values
by attribute name or format field just before serialization or just
after deserialization before assignment.
Added converters, dropped metadata class

I cleaned up some of the indexes[] code so that there's only two points
that touches the nested dictionaries (aside from register):
- metadata_field, which is basic but obscures the somewhat confusing
multi-nested dictionaries
- has_registered_class, which takes a class, or a string representing a
class, or a normalized string representing a class, and determines if
that value is known to the serializer.

Converters:
- Intercept the values just before serialization/ just after
deserialization so that they can be mapped to different types or
coerced.  This is useful for, say, a value which is a bool.  It should
be an int when serializing, and it's an int when it's deserialized, but
we want to interact with it like a real bool.
- Converters are given as a dictionary of string => [func, func] where
both functions take a single value and return a single value.  The first
function is called on the value stored in the object just before it's
serialized.  For the bool example, this can be the built-in int
function, which will convert a bool to an integer for serialization.
The second function is called on the value that is deserialized from the
bitstream.  For the bool example, this can be the built-in bool
function, which will convert an int to a bool.  If either function is
provided, the other must be as well.
- Converters can be defined for specific attributes using
attr_converters, where each key is the variable to apply conversions to.
- Converters can also be defined for a format string, such that any
attribute with that format string will run through those conversion
functions.
- Both attribute and format converters can be specified.  If any
attribute is listed in the attribute converters and its format is in
format converters, the attribute converter will be used.
Removed unused util functions
Removed dropped function
Hide non-public functions

The api is pretty well-defined at this point, so I privatized the things
people don't need to know about.
- I don't think people will be able to unregister classes.
- I also don't think they'll want to check if a class is registered.
- - If necessary, the can always re-register it.
deserialize now takes a class or instance

This makes it easier to use @autoserialized, so long as you always pass
an instance in - the empty constructor will never be used.
Fix base class for python 2.x
Allow multiple serializers by scoping _indexes and register
Default when expected attributes are missing is now an exception
First batch of unit tests
Removing manual testing file
Removing unused util
Added test for AttrConverters (Previously was just FmtConverters)
Merge branch non-mixin