Add `ProcessSignal` and `PIDFile`

This fills out the `ProcessSignal` class and adds a `PIDFile`
class. The `ProcessSignal` is used to manage a running Qs process.
It uses the configured pid file path to read the pid of the running
process and sends a signal to it. This is used by the `CLI` to
stop or restart a Qs process. The `PIDFile` is an internal tool
that handles reading, writing and removing pid files for the
`Process` and `ProcessSignal`. In a separate commit, I will update
the `Process` to use this `PIDFile` as well.
Merge pull request #22 from redding/jcr-process-signal

Add `ProcessSignal` and `PIDFile`
Change `Daemon` module organization

This changes the `Daemon` module organization and changes how its
modules are defined. The file now opens both `Qs` and the `Daemon`
module which changes the amount of leading spaces for almost every
line in the file. This also reorganizes the modules to match how
`Sanford` organizes its modules for its `Server`. This is to make
them similar and easier to see the similarities and differences
between the libraries. This doesn't change any functionality, just
changes the organization of the code.

/cc @kellyredding
Remove `Config` tests

I removed this logic but forgot to remove the tests that go with
it. This is because I can't run the full test suite while I'm
reworking logic. This removes these tests that are no longer
needed.

/cc @kellyredding
Add `Queue` and `Route`

This adds a basic `Queue` and `Route`. These will be used to
define queues and add routes to them. The queue is where job
routes are defined and also knows its redis key. This will be
used when adding jobs to the queue and reading jobs that need to
be processed. Routes are a name and a handler class name. When
a route is validated, the handler class name is constantized.
This will be done when a daemon is started so it can quickly route
and run jobs when they are pulled off of redis.
Merge pull request #23 from redding/jcr-queue

Add `Queue` and `Route`
Add `Logger` and `NullLogger`

This adds a `Logger` utility and a `NullLogger`. These will be
used to handle summary and verbose logging. This uses a null
pattern depending for whichever logging is not "turned on". In
verbose mode, the summary method returns a null logger which will
accept all the logging calls but won't do anything with them. When
in summary mode, this is reversed.
Merge pull request #25 from redding/jcr-logger

Add `Logger` and `NullLogger`
Update and simplify `Process`

This updates and simplifies the `Process` class. It removes all
the signal logic it had as this is now handled by the
`ProcessSignal`. This also removes the `PIDFile` logic that was
an internal helper in the file. It is now its own separate file
that it just requires. The `Process` is now only about running
a daemon and handling restarting it.

This also removes the tmp process file and switches the cli to
using the real one. This was a temporary placeholder while logic
was being reworked.
Merge pull request #24 from redding/jcr-process

Update and simplify `Process`
Add `DaemonData`

This adds a `DaemonData` class which handles "compiling" a daemons
configuration. This is done for speed and to provide a simple
object for passing around the daemon configuration. This provides
methods for easily looking up a queue and route, which will be
used to run a job handler. The daemon data also provides a the
redis configuration which will be used to build a redis connection
when the daemon is run.