Rename implementations to preserve Behavior names

## The Problem

Bane was created with the concept of Behaviors - ways for a server to behave badly by accepting a connection and never sending a byte of data (`NeverRespond`), accepting the connection but closing immediately (`CloseImmediately`), or always sending an HTTP 401 response (`HttpRefuseAllCredentials`). Behaviors were mentioned in the command line help, in the documentation / wiki, and in the code -- where Behaviors were a strategy object plugged into a `BehaviorServer` - a subclass of Ruby's `GServer`, which handled all the business of starting and stopping servers, managing thread pools, binding to a port, accepting socket connections, etc..

I'm about to release a new version of Bane with a new type of behavior: `TimeoutInListenQueue`. This starts up a server that binds to a port, but never accepts any incoming connection, leaving all incoming requests to sit in the TCP listen queue until they time out.  To make this work, I needed to use Ruby's `Socket` library directly instead of relying on `GServer`, which does not provide as low-level of access to the connection/socket setup process as `Socket` does. 

Creating `TimeoutInListenQueue` introduces a problem with naming - what is this new type of thing called?  From the user's point of view, I believe these are still behaviors - they still expect to see them listed in the command line help, and the name 'behavior' has become familiar.  But from an implementation point of view, `TimeoutInListenQueue` is something different -- it responds to the `start` and `stop` messages, like the original `BehaviorServer` did.  This makes this thing unlike the other behaviors like `NeverRespond`, `DelugeResponse`, etc., which were simple strategy objects and _required_ a `BehaviorServer` to function.

## The Proposed Solution

This preserves the name "Behavior" from a user's perspective - `NeverRespond`, `DelugeResponse` and `TimeoutInListenQueue` are all types of behaviors that appear on the command line.  From an implementation standpoint, these are pushed down underneath the `Behavior` module namespace,  introducing the concept of `Services`, things that can be started and stopped, and `Responders`, things that send to and receive from a socket connection provided by GServer.  These are named `Bane::Behaviors::Services` and `Bane::Behaviors::Responders`.

The split looks like this:

Bane::Behaviors::Responders
* NeverRespond
* CloseImmediately
* HttpRefuseAllCredentials
* ... all the old behaviors previously in Bane

Bane::Behaviors::Services
* TImeoutInListenQueue
* ResponderService (the new name for the `BehaviorServer` - I wasn't sure if BehaviorSerer still made sense, given the rename.)
* ... more types of behaviors that hook in to the socket binding / startup process

### Looking forward

In the future, I could imagine having different types of `Responders` - for example, these talk to socket once connected, but there might be special types of HTTP/Rack-aware behaviors that simply plug in to a Rack server - rather than doing a naive handling of the HTTP protocol like we do in `HttpRefuseAllCredentials`.  Perhaps `HttpResponders`?

So this could mean choose to plan ahead and use a more specific name like `SocketResponders` or something like that instead of simply `Responders`.  (Or `Responders::Socket`)


## What do you think?

Do you these names work for you?  Do you have any suggestions?

Thank you, I welcome your feedback!