Move the reporter construction into a factory method.

The factory method lives on the reporter class, as it's going to become
the method with the logic for loading different reporter backends
(for support of things such as etcd).

This is the first step refactoring towards that. There aren't
any current tests, but the method extraction is trivial enough
and I'll build some tests out as I contine to develop the ability
to have multiple reporters.
Add a skeleton zookeeper reporter.

We're not actually using it in any way yet, but this adds the dynamic class loading
so that we can plug other backends in more easily.

The zookeeper reporter inherits from the main reporter where all the code still lives,
so that moving the bulk of the code can be a latter step in refactoring
Actually start returning the new class
Move all zookeeper specific initialization to that reporter.

We're now at the point where all the construction logic is inverted to factories at the variously
correct levels.

Next steps are to start moving zookeeper specific code out of the base classes
Finish adjusting the class hierarchy.

The factory class is now seperate from the base class, which isn't a big deal, but I think is
more elegant (as then the subclasses don't inherit the factory method).

Next up, moving all the code into the child class
Actually move all the code into zookeeper backend.

Leave stubs in the base class which become abstract methods
Remove backend specific factory method in favour of initialize.

Now that all the code is turned round and in the right place, we can elminiate the complexity
of this factory method which is only really doing arg munging.