timer_wrap: Timer.now always update loop time

In `Timer.now` always update the loop time by calling uv_update_time.
Previously we were trying to cache the loop time to prevent extra
syscalls. While a noble goal, it can cause timers to fire early in
certain circumstances. Especially seen in cpu bound work loads or work
loads with synchronous file operations.
pipe_wrap: squelch integer type conversion warning
vm: update API to use options argument

Passing a filename is still supported in place of certain options
arguments, for backward-compatibility, but timeout and display-errors
are not translated since those were undocumented.

Also managed to eliminate an extra stack trace line by not calling
through the `createScript` export.

Added a few message tests to show how `displayErrors` works.
vm: document vm2's changes.

- The caveats no longer apply.
- Document options arguments, including `displayErrors` and the
  different things it means in each place.
- Re-did examples to be more on point, e.g. `runInContext` example
  runs multiple scripts in the same context.
- Documented how `vm.createContext`s meaning has substantially changed,
  and is now more of a "contextifier" than a "creator."
- Reordered vm functions to be readable in order; the concept of
  contextifying needs to come before `runInContext` and
  `runInNewContext`.
- Documented new `vm.isContext`.
- Documented the `vm.Script` constructor, instead of `createScript`,
  since factory methods are silly and we wanted to document the class's
  methods anyway.
- Documented `script.runInContext`.
- Change stability to stable, if I may be so bold.
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.