Made builder pluggable

This means that modellers can create their own neuron types
or NengoObjects or learning rules, etc., and inject them into
the reference simulator. Granted, this requires some pretty
advanced knowledge of the entire codebase, but it's important
that something like this is at least possible.

More concretely, the main change is to move a few things from
Builder into Model, and then restructure Builder such that
build functions register themselves with Builder,
and the only function that is ever really called is
Builder.build, which finds the correct builder function and
calls it with the passed arguments.
This makes it possible to override build functions
and make objects with associated build functions.
It also provides a consistent interface through which
to build an arbitrary Nengo object; now, regardless of the object,
calling Builder.build(object, model=model) will insert
the appropriate build artifacts into the passed model
(if a build method has been associated with that object type).
This opens up the possibility that the user can do the build
manually, and pass a built Model to the simulator.
This is definitely not the normal use case, but we do this
in `test_simulator`, so it's now possible to pass in a model
instead of a network to the simulator (but the network must
be explicitly passed None to do so).

Other changes
- Cleaned up docstrings in builder.py
- Moved `assert_named_signals` into Signal and added test
Added rectified_linear example

This is an advanced example of how you can define a new neuron type
within a user script, if you want to do that kind of thing.

Mostly, it's a justification for the pluggable builder changes in
the previous commit. I don't believe that you could do this example
before the previous commit without doing some pretty hacky stuff.