The async_wrap API will be changing substantially and breaking the
existing API. So remove the current tests and add them back after
they've been reimplemented.

Classes like TLSWrap hold a pointer to another StreamBase instance. The
lifetime of these two are independent and allowed one to be retained
while the other is cleaned up. In the case of TLSWrap, the private
member TLSWrap::stream_ would be deleted, while the TLSWrap could still
attempt to access it to see if it was alive.

Give StreamBase a destruct callback to notify when the class is being
cleaned up. Use this in TLSWrap to clear out the field.

RandomBytes and PBKDF2 were using the same "generic" ObjectTemplate for
construction. Instead create one for each that is properly named.

Instead of wrapping several providers into PROVIDER_CRYPTO, have them
all be named after their class. Rename other providers to also match
their class names. With the exception of Parser. Which is actually
HTTPParser.

Add PROVIDER_LENGTH to make better checks in WrapperInfo().

The array math in JS converting the in64_t to a safe integer is
unnecessary. Instead set the field to a double and allow internals
direct access to the array to reduce overhead. Not ideal, but gets us
the same number of values and simplifies the JS interface.

Allow handles to retrieve their own uid's by adding a new method on the
FunctionTemplates. Implementation of these into all other classes will
come in a future commit.

Add the method AsyncWrap::GetAsyncId() to all inheriting class objects
so the uid of the handle can be retrieved from JS.

The call to async_wrap.setupHooks() will soon become an internal call.
While other public APIs will be exposed through async_hooks. In
preparation for this, only allow SetupHooks() to be called once. If
called again, or if a non-function is passed, throw.

Getting mechanics flushed out for both the necessary JS and C++ APIs.

Currenty builds and runs, but complete implementation is coming.

Check the correct array to see if hooks can be executed.

Also did:
* Turn TickObject() into a function
* Split the function in half so it can be inlined
* Fix how uid flags are set
* Export kScopedTriggerId for use in setupInit()

Also change a couple things to retrieve the initTriggerId the same way
in all cases.

The placement of setting/updating the triggerId needs to be tested to
make sure basic assumptions are met.

Also fix propagation of the triggerId for fs.open(), remove adding
information to the internal unordered_map for fs.openSync() and return
the Float64Array to simplify usage.

cluster is still slightly messed up, as I figure out how to handle the
"faux" handles passed to net.

Properly propagate the triggerId in a few more modules.

Add function on native side to run AsyncWrap::Reset() from JS. Only add
this to TCPWrap, since it's the only place necessary.

* Setup the currentId and triggerId during bootstrap.
* Assign _asyncId and _triggerId on construction of Timeout
* Always run emitBefore/emitAfter in timers to make sure ids are setup
* Reset ids after after() hooks are called, not before

Instead of always calling into emitBefore/emitAfter, set the ids
manually if there are no hooks to call. Better performance.

Safely enable()/disable() hooks while hooks are being processed.
Otherwise the array length will change and hooks that should/shouldn't
have been processed will be.

In the case of an exception being caught by _fatalException(), make sure
to always run the after() callbacks to let the user know the callback
has completed.

Include test to make sure after() is triggered correctly, including
having the correct currentId.

Properly set the triggerId for the nextTick() call by using the _asyncId
set on the stream.

Point the _asyncId and _triggerId of the TickObject used by
runMicrotasksCallback() to the void. When the PromiseHook API is
implemented in V8 will address and properly propagate the ids.

Add NODE_TEST_WITH_ASYNC_HOOKS environment variable to allow running
tests with init/before/after/destroy noops to make sure that basic
mechanics work properly across all tests.

Place restoreTmpHooks() closer to setupTmpActiveHooks() to make it more
apparent what each is used for.

Switch to using a v8::Eternal array to retrieve the provider strings
passed as the  "type" to the init() callback.

Instead of always passing in a Float64Array to getIdsFromFd()
preallocate one during initialization and write to those fields
directly.

When emitAfterS() is called, make sure the id passed in is the same id
that's on the stack.

destroy() hooks from JS should also be called async, but instead of
trying to do this in a setImmediate, just use the same list that is used
for native ids.

Add NODE_TEST_HANDLE_ACCESS, which tests if a resource aborts if
inspected at the end of the process (specifically if the resource has
been cleaned up on the C++ side), and NODE_CHECK_ASYNC_DESTROY, which
checks if destroy has been called on the same id twice.

This was originally done as a safety measure, but fails in practice if
a clear*() is run on the same handle that's currently executing its
callback.

In some cases, like triggering the microtask queue, there is no id
(though that should change in the future). So instead trigger that
execution is happening in the void, and return early if destroy is
emitted on the void.

async_hooks does not allow recovery from errors because it's currently
unknown what will happen to the state of the application if that
happens. So instead, force the application to print an error message
then either exit or abort. Depending on whether the user passed
--abort-on-uncaught-exception.

exit() is used instead of reallyExit() to allow any 'exit' events to
fire.

ForceSet() everything with v8::ReadOnly | v8::DontDelete to make sure
none of the object properties can be overridden.

In order to get a stack tracker that is performant in JS had to do some
ridiculous stuff. This allows the stack to be tracked from both C++ and
JS with almost no overhead, and allows it to unwind properly in case
there's a fatal exception.

Instead of using a CHECK(), print an error message to the user. Check if
--abort-on-uncaught-exception has been passed, and abort if this is the
case. Otherwise exit(1).