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).

The .offset attribute is now a ReadOnly set to 0, for backwards
compatibility. I'd like to remove it in the future (pre v1.0).

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: 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.

Because of this re-introduction, and since there is no more SlowBuffer
type, the SlowBuffer method has been re-purposed to return a non-pooled
Buffer instance. This will be helpful for developers to store data for
indeterminate lengths of time without introducing a memory leak.

Another 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: 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: remove c-style casts
buffer: deprecate legacy code

Several things are now no longer necessary. These have been deprecated,
and will be removed in v0.13.
buffer: implement new fill behavior

Old fill would take the char code of the first character and wrap around
the int to fit in the 127 range. Now fill will duplicate whatever string
is given through the entirety of the buffer.

Note: There is one bug around ending on a partial fill of any character
outside the ASCII range.
src: add node_isolate's from stable merge

Add node_isolate argument to new code from recent v0.10 branch merge.
smalloc: implement new v8 api

Implements some of the new v8 API that'll be coming. Hopefully this will
help instantiation time in the long run.
src: proper API export for Windows

So that Windows users can properly include smalloc and node_buffer,
NODE_EXTERN was added to the headers that export this functionality.
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.
stream_wrap: allow onread to pass data to callback

Instead of forcibly creating a Buffer from the incoming data and passing
it to MakeCallback, allow for the data to be passed to a callback. This
should allow for a more interesting array of performance improvements as
operations can be performed directly on the data before adding the
overhead of creating a Buffer and passing it to js.