node: add AsyncListener support

The AsyncWrap class has been added as a base class for everything that
will be performing an asynchronous request. This is meant to be a
simpler way to track when requests have gone out, and to allow users
hooks to know when this happens.

Currently only ReqWrap and HandleWrap are covered. Full support will be
added in the future for all the *Wrap classes.

This comes with a new API:

* process.createAsyncListener(listener, callbacks, domain): This will
  create an AsyncListener instance that can be added and removed when
  necessary. The "domain" passed will propagate to each callback unless
  the listener at some point returns a new object.
  Returns the new AsyncListener instance.
* process.addAsyncListener(listener, callbacks): Will create a new
  AsyncListener instance an immediately add it to the listening queue.
  Whatever value is returned from "listener" will propagate to the
  callbacks.
  Returns the new AsyncListener instance.
* process.removeAsyncListener(instance): Remove an AsycListener instance
  from the current queue and stack.
  Returns undefined.

Explanations for each callback:

* listener(): Callback that's called immediately when a *Wrap, Timer or
  nextTick is queued.
* callbacks.before(context, domain): Run immediately before the async
  callback is about to run. "context" is the "this" of the caller,
  except in the case of nextTick. Where the callback object is passed
  instead. "domain" is the object passed to createAsyncListener() or
  returned from listener().
* callbacks.after(context, domain): Same as before(), except run
  immediately after the callback has run. Except if the callback has
  thrown, in which case this will not be called.
* callbacks.error(domain, error): Called when a callback has thrown.
  Currently the "context" is lost in this case so it's not passed, but
  the "domain" object still is. If the error is properly handled the
  return true to continue program execution. If multiple error handlers
  are queued all will be called, and if any one returns true then the
  error is assumed to have been handled.

In the case of callbacks, they are only allowed to throw two levels
deep. Afterwards the error handler will always return false. This is to
prevent infinite recursive throws.

As you'll see, the domain module still exists. Full support has been
added in it's previous form until a complete solution is patched. The
goal is to have the domain module use AsyncListeners and be as far
removed from core as possible. When that day comes, I'll fully enjoy
torching every last line of integrated code until it's all burnt
stubble.