env: async provider type should be uint

All providers must be listed in async-wrap.h.
src: improve function names

run/load/unload aren't good descriptors for what the function is about
to do. Not a ton better, but init/pre/post are an improvement.
timers: new timers get asyncId

Attach a new async id to every instantiated timer.

It would be much faster to simply store the int64_t as two uint32_t and
read it out using id[1] * 0x100000000 + id[0]. There are two problems
using this approach. The simpler one is endianess. The more complicated
problem is that we allow users to set their own async id callback.

There probably is a better way to improve this, or just remove
setUidCb() from the API (I think it's an unnecessary addition).
node: nextTick object receive asyncId

process.nextTick now also returns the created object so the asyncId can
be checked. Likewise an undefined 'data' field is set for users to be
able to attach data without needing to change the object map. Finally,
the created nextTick object is made the context of the called function.
This way users can retrieve their stored data without needing function
closures.

Update message test to show new correct output.
async_listener: expose async id uint64 as 2 uint32

Using the following bit of math hackery, it's possible to extract the
int64 value without needing to convert it to a double:

asyncUidPtr[0] * 0x100000000 + asyncUidPtr[1]

Though the index used is dependent upon the endianess of the machine,
but regardless it's a much faster way to access/increment the uid than
via a function call.

Unfortunately there's the API that allows users to set a JS callback.
This complicates things and I haven't figured out a good solution around
the issue.
test: fix test-tcp-wrap-listen.js
windows: fix build break

Floating https://github.com/MSOpenTech/libuv/commit/7b9b4d5781d1278a2e2d1432d56b23f2abc49b93
Added an assert.
async-wrap: prepend v8::

Somehow forgot to prepend v8:: to a bunch of calls to v8::Undefined().
fs: add a final guard for receiving req object

As new APIs are introduced it's possible one forgets to pass a req
object, and instead passes a calback (the old convention). This is a
safety mechanism to make sure that doesn't happen.