RewindBuffer: Implement dump, load and insert

* There are a number of scenarios where StreamMachine needs to be able to
  manipulate the Rewind buffer.  For instance, when restarting the server,
  we need a way to transfer buffer state from the old instance to the new
  one.  A new slave also needs a way to prime itself to the current buffer
  state.  These functions are a first step in that direction.
* dumpBuffer writes a binary stream that contains the rewind buffer and
  metadata
* loadBuffer reads that same stream, turning it back into the proper objects
* _insertBuffer is used to inject buffer chunks into the live buffer, doing
  minimal checking to make sure we aren't repeating data.
Implement handoff for rewind buffers and sources in Standalone mode

* On SIGHUP, Standalone mode will now start a new process and go through a
  handoff process by which it passes over sources, the source_in server,
  the standalone server and all rewind buffers
* Listeners are currently not transferred to the new process
Convert outputs to prioritize client socket

* Use req/res to route request and send headers, but then just hold on to the
  underlying connection socket. Opens the door for passing that socket on to
  a restarting process.
* Only send headers and preroll on an initial connection with req and res.
* Rename LiveMP3 to RawAudio
* Get rid of old writeHead calls in SourceIn error paths
Add initial support for taking listeners through handoff

* Core: Fix handle close callbacks that weren't ever getting fired
* Master: Fix keys for rewind buffer send... Typo was causing buffer to get
  assigned to the wrong stream
* SourceIn: Asking winston to log the listen spec was crashing when it was
  a handle
* Outputs: create `@client` object, refine handling
* Slave: Add support for listener handoff
* Slave.Stream: Use client object from output

* FIXME: Icecast output isn't working correctly on a handoff because we aren't
  checking to make sure that the metadata injection is keeping the same offset
  in the data.  Need to figure out a way to flush the Icecast writer before
  handing off or bringing state along for the new writer.
Fix icecast handoffs by passing how many bytes are remaining until metadata
Reorganize code for operation modes into separate files
Fix Master and Slave modes

* Move HandoffTranslator to modes/base
* Master: Be consistant in emitting 'config', not 'streams'
* Master: Add `stream_stats` call for slaves, to get stream vitals
* Master.Stream: Implement `_vitals()`
* Master Mode: Fix admin server setup and start to prepare for handoffs
* Slave Mode: Start to prepare for handoffs
* RewindBuffer: Add a listener to allow sources to emit `vitals` instead
  of header.
* Slave: Ask for vitals during SocketSource setup
Extend use of `vitals` event as a replacement for `header`

* Get some naming consistency. stream_key -> streamKey and emit_duration ->
  emitDuration
* Master: store slaves in a hash keyed by id
* Source: Cache vitals, make them always available via the `vitals()` func
* RewindBuffer: Just look for `vitals`, not `header`
* Source: Add duration and ts into the data chunk in the source, instead of
  waiting to the stream level to timestamp. Also send streamKey in the data
  chunk.
Make sure config updates get sent out to slaves
Allow a new slave to load the master's Rewind Buffer

* Master: Add StreamTransport app for serving rewind buffer data
* Slave: Make a request for rewind buffer in SocketSource startup
* RewindBuffer: Don't try to dump buffer if there isn't anything there
* Admin: Use `@master`, not `@core`
Implement handoff for master mode
Fix socket proxy handoff in master restart

* Master: Fix call to attachIOProxy when we start listening
* Slave: Clean up how SocketSources are created
* RewindBuffer: Fix disconnect logic
Differentiate process titles for each operation mode
Merge pull request #1 from StreamMachine/DumpRewindBuffer

Implement Restart Handoffs