Started work on hot reloading configuration. The approach I'm aiming for is
to create a new Handler which'll rebuild all the middlewares with their new
configuration.

The first part of this is to make it so that Middlewares can be rebuilt on the
fly with a new configuration. This commit handles this by creating a
MiddlewareFactory interface, which the Middleware Configurations are going
to implement.

The next part is to make the Handler how swappable itself. That is, on reload
we keep serving requests with the existing handler, but create a new one
and then swap it out the new with the old.

The last part is to try to make the "global" settings also hot swappable.
Things like the logger, or the Server's ReadTimeout.

The goal with swapping out the entire handler is to make sure requests flow
through a consistent set of middleware. My initial thought had been to load
each middleware individually. But reloading requires coordination. What if a
new router config uses a new upstream, but the upstream hasn't been reloaded
yet?  By rebuilding the entire chain, offline, we can present a consistent
snapshot at all times (plus, we can easily rollback on error).
Introduced a first class Garnish object which is the primary http.Handler for
all requests. It's sole job is to hand of processing to the acutal Handler.
However, this level of indirection let's us swap the handler during a reload.