Refactor the ControlDaemon

Refactor the ControlDaemon out into control.py.  This is the first
step in reworking the control thread such that it will be compatible
with multiprocess.
Refactor limit object construction

Refactors limit object construction to decouple the control daemon
from the middleware.  Introduces the LimitData class, which acts as
a go-between for passing raw limit data taken from the database to
the middleware, which is then responsible for constructing the
routes for it.  This will allow a later refactoring which will
permit the ControlDaemon to run in a separate process; in this
case, the LimitData subclass used by the middleware will know how
to get the limit data from the LimitData subclass used by the
ControlDaemon.
Use function registration for commands

Pull command implementations out of the ControlDaemon class and
switch to a function registration methodology.  This removes the
ugly hack that all non-commands in ControlDaemon must begin with
an underscore, and will make the ControlDaemon easier to
understand, and to extend with support for multiprocess.  This
also makes it easy for third parties to define new ControlDaemon
commands, if desired.
Remove unneeded underscores

After refactoring command functions out of the ControlDaemon,
the '_' prefix is no longer necessary.  Remove the '_' prefix
from ControlDaemon everywhere it was used on something meant to
be public (the _commands map and _register() continue to use
the prefix, since they really are meant to be internal).  Also
corrects the middleware to get the LimitData using get_limits()
instead of using a direct reference; this will allow the multi-
process version of ControlDaemon to return a different object.
Discovered a couple of minor pep8 errors
Call ControlDaemon.start() explicitly

Previously, instantiating the ControlDaemon would automatically
spawn the daemon thread.  This changes the ControlDaemon so that
the start() method has to be called explicitly by the middleware.
Add MultiControlDaemon

Add the MultiControlDaemon, which is used in multiprocess
Turnstile to allow the control daemon to be in a separate
process.
Add a switch to use MultiControlDaemon

Adds (and documents) the configuration option "control.multi" to
control using the multiprocess-compatible MultiControlDaemon as
the control daemon class.
Add a to_bool() function

Streamlines and unifies testing if a string signifies a true value
or a false value.
Refactor configuration

Refactors configuration by creating a new Config class.  Also
augments configuration: a "config" parameter can be provided in
the paste.ini to specify an alternate configuration file.
Unifies configuration needed by the Turnstile middleware and
the tools, with backwards-compatibility.

Note that the new configuration object is available in the WSGI
environment, in the 'turnstile.conf' value; this should be
contrasted with the 'turnstile.config' value, which is now
deprecated.
Drop parse_config()

Drops parse_config() from the Turnstile tools, as it is now
replaced with a dedicated Config class.
Garbage collection

Remove some unused pieces, such as unused imports and unused fakes.
Update control daemon calling convention

Update the calling convention of the control daemon.  Also refactor
the way the middleware and the control daemon access the database
handle, to better handle running the middleware in its own process.
Split MultiControlDaemon

Effectively splits MultiControlDaemon so that it runs in two different
ways: one as the client side, run by the middleware (invoked by calling
the start() method), and one as the server side, which will be run by
a script (invoked by calling the serve() method).
Create multi_daemon program

Adds a multi_daemon program which will start the MultiControlDaemon in
daemon mode.
Add copyright headers and a note to scripts

Add copyright headers to the scripts in the bin subdirectory.  Also
add a note indicating that these scripts are not directly installed,
but rather that entry points are used.
Move to_bool()

Moves to_bool() to a more convenient location: a static method of
turnstile.config:Config.  This will allow third-party components that
access the configuration to use this convenience method.
Rename 'config' attribute of middleware

For backwards-compatibility, the 'config' attribute of the
middleware--which was expected to be accessed by third-party
components--has been renamed to 'conf' and a new 'config'
property has been created which returns a backwards-compatible
two-level dictionary.
Remove an extraneous trailing space.
Update documentation

Update of README.rst to describe new configuration options,
document the use of the Config class and its new to_bool()
method, describe updated configuration parsing, and explain
the use of the multi_daemon program and related configuration
options.