smalloc: initial implementation

smalloc is a simple utility for quickly allocating external memory onto
js objects. This will be used to centralize how memory is managed in
node, and will become the backer for Buffers. So in the future crypto's
SlabBuffer, stream's SlabAllocator will be removed.

Note on the js API: because no arguments are optional the order of
arguments have been placed to match their cc counterparts as closely as
possible.
smalloc: add api to manually dispose Persistent

If the user knows the allocation is no longer needed then the memory can
be manually released.

Currently this will not ClearWeak the Persistent, so the callback will
still run.

If the user passed a ClearWeak callback, and then disposed the object,
the buffer callback argument will == NULL.
buffer: use smalloc as backing data store

Memory allocations are now done through smalloc. The Buffer cc class has
been removed completely, but for backwards compatibility have left the
namespace as Buffer.

The .parent attribute is only set if the Buffer is a slice of an
allocation. Which is then set to the alloc object (not a Buffer).

A few alterations have been made to how arguments are either coerced or
thrown. All primitives will now be coerced to their respective values,
and (most) all out of range index requests will throw.

The indexes that are coerced were left for backwards compatibility. For
example: Buffer slice operates more like Array slice, and coerces
instead of throwing out of range indexes. This may change in the future.

The reason for wanting to throw for out of range indexes is because
giving js access to raw memory has high potential risk. To mitigate that
it's easier to make sure the developer is always quickly alerted to the
fact that their code is attempting to access beyond memory bounds.

Because SlowBuffer will be deprecated, and simply returns a new Buffer
instance, all tests on SlowBuffer have been removed.

Heapdumps will now show usage under "smalloc" instead of "Buffer".

ParseArrayIndex was added to node_internals to support proper uint
argument checking/coercion for external array data indexes.

SlabAllocator had to be updated since handle_ no longer exists.
buffer: expose class methods alloc and dispose

Expose the ability for users to allocate and manually dispose data on
any object. These are user-safe versions of internal smalloc functions.
buffer: reimplement Buffer pools

This is an undesirable, but for the time necessary since small chunks
are still too slow. It will continue to be improved as alternatives are
discovered.

One important change to Buffer pools was that they are only allocated if
the requested chunk is < poolSize / 2. This was done because allocations
are much quicker now, and it's a better use of the pool.
buffer: deprecate legacy code

Several things are now no longer necessary. These have been deprecated,
and will be removed in v0.13.
buffer: remove c-style casts
slab_allocator: remove SlabAllocator

SlabAllocator has been completely removed. Instead each request uses the
incoming data and creates a new Buffer. This should remove any prior
memory leaks.

Performance isn't much worse, but still not where it should be.
buffer: add dispose to Buffer instance api

Users now have the ability to manually dispose a Buffer when it's no
longer needed. This will transform the instance into a zero-length
Buffer. If the instance was a slice then the memory is not actually
released, but the pointer to the parent allocation is removed.
tls: remove SlabBuffer

Further remove external pooling mechanisms. This does cause a small
performance regression, but this should be solvable once everything is
centralized.