multi-context wip
node: move tick callback lazy load code block

It's possible to require('domain') within a MakeCallback, which means
the env->tick_function_callback() will change. So moving the lazy load
block to just before the call of the function will allow
SetupDomainCallback to override the method before it's used.
node: move in_tick to C++

It's only going to save half a nanosecond, if that, but feels better
having all this logic in the same location.
node: further move towards new domain api

Small steps are being taken to manage the async listener change. This
will definitely introduce performance degradation, but will be fixed in
the next few commits. Changes include:

Removed _tickDomainCallback. Those two functions were to be merged
eventually, but doing it now removes a lot of complexity.

Move setting up process.domain into src/node.js. So now technically Node
is always using domains. This will be necessary once we instead actively
check for async listeners. It will be a cheap check, so always having
that domain functionality ready doesn't come at noticeable cost.
node: switch domain share from Array to Object

Also changed name from domain_array to domain_box.
node: remove domain specific implementation

Now that the domain object has been moved into src/node.js we're always
in a "using_domains" state. So no need for all the extra code.
node: remove inTick from JS

There is no need to set if we're in a tick from JS. Regardless of where
the queue stops processing we'll have to return back to C++. So instead
we'll set whether we're currently in a tick from there.
env: switch DomainFlag::count to ::flag

The field now no longer tracks the number of domains in the stack, but
whether there's an active domain or not. The name change seemed
appropriate.
process: cleanup after method use

There's no need to run process._setupDomainUse twice. Remove it after
it's done running.
test: add asyncListener tests

These tests should cover all basic uses of the asyncListener API.
node: add asyncListener skeleton

The basic API entries are in place. Next is to put all the proper
entries in env.h, then actually get the hooks in the proper locations.
env: add entries for AsyncListenerCount

Add needed class entries in Environment so we have access to the needed
fields to call the async listener callback wrapper from C++.
process: call asyncListener from ReqWrap

If there's an active async listener, then call it from ReqWrap.
process: don't process async listeners if exiting