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
SQUASH: review fixes
SQUASH: move to async-wrap.h and async-wrap-inl.h
tls_wrap: revert async_wrap support

Since crypto uses ObjectWrap it's difficult to get things working
properly. So going to punt on this for now and revisit when other
internals are more solid.
SQUASH: move request object to AsyncWrap

The request object itself is now part of AsyncWrap. This also means
removal of TLS and ZLib, since they both use ObjectWrap.
node: remove tickCallback lazy load

It's going to be called as soon as Node starts up anyways. So why waste
logic on lazy loading it.
SQUASH: use AsyncWrap specific MakeCallback

AsyncWrap now has an implementation specific MakeCallback.

This breaks Domains, as it will no longer check if "using_domains" then
call MakeDomainCallback. So, time to make domains use async listeners.
test: modify async listener tests

By removing the async listener at the end of the page for some reason no
other error handlers are working properly.