Move files out of unspecified "common" namespace
Use new log sign_message/log_signature api

All protobuf logger usage has consisted of manually prepending a custom
log signature to the each and every log message. This commit
standardizes the approach by making `log_signature` an included method
along with `sign_message` for use in signing a log message in the case
of block usage (which is all cases currently).

Any non-block usage of log methods will auto-sign each string message
parameter given.
Fix syntax that was bugging me

Things including, but not limited to:

* No parens around method params.
* Parens and no spaces around control flow expressions (e.g.
if(somecondition))
* Move away from percent-based c-style sprintf string interpolation to
regular double quote interpolation.
* Use `until` instead of `while` when it makes things more clear, and
vice versa.
* Wrap method call arguments in params.
* Use explicit exception variable instead of global `$!`.
* Wrap complex conditional expressions in appropriately named predicate
methods.
* Remove line-ending or excessive whitespace.
Update stats object api
Centralize server request initialization

Pulls from each server object the initialization of request-specific
objects, such as the wrapping request and response, stats, and client
peer (if any). This makes us less error prone in making changes to the
implementing server types.
Refactor Service API, add ServiceDispatcher

Add ServiceDispatcher class to take care of the core concern of sending
calls to a service method when a server request has been received. The
ServiceDispatcher is also responsible for retrieving the response from
the service and ensuring the response type is appropriate.

Previously, the ServiceDispatcher functionality was shared between the
Server and the Service. The new role of the Server is to simply inflate
the request into the wrapper from the socket and hand it to the
ServiceDispatcher. By invoking the dispatcher, the server then
serializes back to the socket either the response or error.

The new role of the Service is to simply act like a PORO. The rpc DSL
is still defined on the Service but all method calling and
request/response manipulation is left up to the dispatcher. This
significantly simplifies both server and service code and allows us to
move away from the hook implementaiton used before using
`method_added`, aliasing methods and hiding their implementations.

One feature that has been removed from the server side due to lack of
use in practical applications is async responding. While a "nice to
have", it significantly complicated the process of crafting responses
to rpc requests. Async responding may be back in a future version, but
I would imagine we'd use something closer to an actor implementation or
a Fiber-based approach.

All in all, this feels like a much cleaner approach.
Remove client async capabilities

The async client calls are the perfect example of a cool idea built
before a necessary implementation was needed. I'm removing it for now
from the client API in favor of cleaner, easier to test (and refactor)
code.

I imagine this could make it's way back into this gem in the form of
celluloid actors or similar.
Fix stat method/service integration with service dispatcher
Remove (failing) test that is verifying ruby blocks behavior
Change back to implicit request/response service objects

When the ServiceDispatcher was introduced I added an explicit approach
to request and response objects; both must be given and the response
object must be explicitly returned from the method.

While it made sense programmatically it just doesn't feel "ruby-ish".
Here are some of the changes I've made to get back to a simpler
approach:

* Service class is given the name of the method the dispatcher will
invoke and the request bytes.
* Service#request and Service#response are lazily loaded objects of the
appropriate type for the given rpc method.
* Service#request deserializes the given bytes.
* Service#respond_with provides sugar for assigning the response to a
different object.
* Privateized several service methods that should not be externally
accessobile (e.g. respond_with, rpc_failed, request)
* ServiceDispatcher no longer deals with setting up the types for
request response.
* ServiceDispatcher is still responsible for type checking/coercion of
the response object.

I believe the addition of `respond_with` in addition to implicit
request/response objects solves the old issue where you had to use
`self.response=` to overwrite the response. It also gives this more of
a rails-style controller feel.
Gobify Service#respond_with
Use bracket notation instead of #delete on Service.configure
Merge pull request #28 from localshred/bj/service_internals

Service API Refactor