node: don't share state with in_tick/last_threw

There was no need to share state between C++ and JS for these two
values. So they have been moved to their respective locations. This will
help performance only a tiny bit, but it does help code complexity much
more.
test: add asyncListener tests

These tests should cover all basic uses of the asyncListener API.
async_wrap: add AsyncWrap and asyncListener API

The AsyncWrap class simply allows to track asynchronous event flags so
MakeCallback can make intelligent decisions about what methods to call.
This way we can avoid much of the overhead that was inflicted upon
domains.

The AsyncWrap class is now inherited by several other classes, including
ReqWrap, HandleWrap, TLSWrap and others. This will allow us to call a
callback whenever one of those classes is instantiated. Allowing us to
know that some possibly asynchronous event will be fired.

Also added were process.addAsyncListener/removeAsyncListener.
addAsyncListener should be passed a callback, which will then be called
when any of the AsyncWrap inherited classes are instantiated, when
process.nextTick/setTimeout/setImmediate/setInterval are passed a
callback.

The argument passed to the async listener callback is the context of the
asynchronous event. Though in the case of process.nextTick it simply
passes the object containing the callback.
node: remove runAsyncQueue global check

I forget why this was initially added, but is no longer required.
node: extend _asyncQueue for domains

Now _asyncQueue is an object that will contain information about the
async listeners and any domains that are attached. This will run a
callback assigned to the "before" field before the callback is run, and
"after" callback after the callback has run. Each field is optional.
node: remove unnecessary assignation
node: don't require listener to be passed

This way the before/after/errror callbacks can still be attached to the
context w/o needing to run a listener and pass a domain.
node: add async listener error handling

The first thing when _fatalException is run is to then run
process._errorHandler. This will run though and first check if there are
any error callbacks waiting in the async listener queue to be run.
WIP: take a step
WIP: each run listner creates unique object

Instead of trying to keep everything in a list of arrays, each one is
now it's own unique object that is used to store all relavent
information about the request, and is also used as a unique id to remove
the listener from the queue.
timers: run listeners when HandleWrap is absent

Just running the asyncQueue whenever would cause double entries to
occur, so instead we place running the async queue around when a
HandleWrap is going to be instantiated.
test: fix async listeners test

It is impossible to trigger a set of tests by running a callback within
one of the tests, around which you've run an async listener. This is
because the callstack will follow the callback to the next set of tests.
test: fix async listener error tests