Domains bound to pipes.

This is an easier way to handle errors in pipeworks, and compromises the following changes.

1. For each instance of `pipeworks()` created we give it an overall domain.
  1. It's found in the `this.pipeDomain`
  2. We bind all functions executing in the pipeline to this domain through .bind(). .bind() returns a callback function with the same signature, but it's bound into the node domain.
2. We track the state of arguments passed into each part of the pipeline execution. This is so we can easily access the overall state of the pipe on an error condition.
  1. This is found in the `this.pipeState` variable.
  2. Literally just `context, next` or whatever variables are passed to the callback
  3. We need to do this because of how domains work. They don't provide a great way to bind contextual data bits to themselves. So we circumvent this issue by encapsulating the the callbacks at each pipe execution stage with a domain, and track the current state of the pipe in the pipeworks prototype. That way we can siphon to an error pipeline, and the user can choose to siphon back to the main pipeline post error to complete the pipeline.

Here is a good example of how to use this business.

```javascript
//Sorry for bad variable names.
var pipeworks = require("pipeworks");

var p = pipeworks();
var ep = pipeworks();

ep
  .fit(function(context, next){
    //Here we alter the original pipelines state with some new handling
    //and go to the last piece of the pipeline
    next(context + " recovered from error");
  });

p.pipeDomain.on("error", function(e){
  //We subscribed to our pipelines error domain
  //Here we access the last arguments passed to the pipeline 
  console.log("Error caught in "+e.message +" redirecting to error handling pipe.");
  if(p.pipeState) {
    //Here we access the arguments passed to the pipe that errored out.
    var pipeState = p.pipeState;
    //We siphon those arguments to the error pipeline for execution.
    var args = Array.prototype.slice.apply(pipeState);
    ep.siphon.apply(ep, args);
  } else {
    ep.siphon();
  }
	
});

p
  .fit(function(context, next) {
    //Start execution
    next("Whoop!");
  })
  .fit(function(context, next) {
    //Whoopsie an error was thrown in this pipe. We need to handle it.
  	throw new Error("Middle Context");
    next(context+" "+context);
  })
  .fit(function(context, next) {
    //Pipe completed!
    console.log(context);
    next(context);
  })
  .flow({})
```