Send data from the servers, not the server module

Instead of having the server module call send_data, which it does not
define, have it return a response and call send_data from the servers
themselves.
Conditionally pause GC with a block

Now that the servers are responsible for sending data, they also need to
handle pausing GC. Add a new gc_pause method that takes a block and
conditionally pauses GC when yielding the block.

Each server wraps the handle_client & send_data call in this method
call.
Consolidate response encoding

Instead of returning a response object and requiring each server to
encode it, encode the response in handle_client and return it. That
way, each server is simply responsible for streaming the data as it sees
fit.

It also allows stats tracking and logging to be centralized inside the
server module.
Consolidate request/stat logging
Remove the read buffer from the socket worker

Since the socket worker reads all of it's data from the socket, there's
not need to keep the buffer in the mix. Instead, simply read the request
data from the socket.
Consolidate initializing request

Instead of making each server responsible for initializing the request,
response, and stats objects, just call it from inside handle_client.
Rework how requests are handled

Continuing to solidify the server API, rework how requests are handled.

- Rename handle_client to handle_request
- Pass request data to handle_request (instead of using an ivar)
- Rename parse_request_from_buffer to parse_request_data
- Pass request data to parse_request_data
Rework the server module

Solidify the server API even more. Instead of initializing a bunch of
instance variables and simply accessing them whenever, create methods to
handle decoding requests and encoding responses.

Encoding responses got the most significant overhaul since errors and
responses are handled differently. Now PB errors will simply initialize
a new PB response wrapper with the error information instead of taking
a pre-initialized response object and setting error values on it.
Conditionally pause GC in the pause_gc method
Remove RPC::Server from the socket server

Since the socket server spins up workers to handle requests, it doesn't
need to include the server module.
Use an explicit return in ensure block

In order to override what is returned from a method when using ensure,
an explicit return must be used.