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.
buffer: use smalloc as backing data store

Memory allocations are now done through smalloc. The Buffer 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.

The new Class Method "alloc" has been added, along with documentation,
which is a user safe extension of smalloc._alloc.

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: 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
smalloc: implement UCAlloc

UCAlloc is a quick wrapper around external memory. The caveat is the
developer needs to trigger when the data is no longer necessary. Failing
to do so will lead to a memory leak.

v8 can only SetWrapperClassId on Persistents. Which means the data won't
be viewable from a heap dump. Because of this an additional property
isUCAlloc is set so they are identifiable otherwise. Also length is
set so the developer can view how long it is.

Do NOT, repeat NEVER, take a slice of a UCAlloc.
buffer: convert UCAlloc to Buffer instance

In the case that data attached via UCAlloc needs to become a full Buffer
instance, pass the object to ucallocToBuffer.
stream_wrap/udp_wrap: 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.