Add SystemHeapAllocator and related utility classes

This SystemHeapAllocator class provides utility functions which
work with the SystemHeapAllocator defined in the public API, making
it more convenient to use.

SystemHeapAllocated is meant to be used as base class for objects
that are to be allocated using SystemHeapAllocator. It defines
operators to use placement-new with a SystemHeapAllocator, and
an allocator-aware Delete<T>() template function that must be
used instead of global delete operator.

The SystemHeapAllocatorObject class is intended to be used as a base
class for objects which are allocated via a SystemHeapAllocator. The
class defines custom new/delete operators. Allocation is done via
placement-new, and the allocator will embed a copy of itself (read:
a pointer) in the allocated memory area, so the delete operator can
retrieve it to perform the deallocation.

Functions v8::SystemHeapAllocator::{get,set}Default() access a static
global which is preinitialized to an allocator (LibcSystemHeapAllocator)
that uses the system C library malloc() and free() functions.
Use SystemHeapAllocator[Object] for heap-allocated objects

Convert a number of classes which were allocated using new/delete to use
placement-new and the Delete<T>() template with a SystemHeapAllocator.
Wherever possible, the versions that accept an Isolate are used, which
more clearly states the idea that the allocated objects belong to a
particular Isolate.

The change affect classes which were previously based on Malloced, too.
Use SystemHeapAllocator instead of Malloced for Segments

Make Zone allocate Segments by using the SystemHeapAllocator of
its corresponding Isolate, instead of using Malloced.
Remove Malloced class which is not needed anymore

All uses of Malloced have been replaced by SystemHeapAllocated, or by
other means of memory allocation. The class is not needed anymore.
SystemHeapAllocator-aware Array::{New, Delete} template

The Array<T> template provides the static functions Array<T>::New() and
Array<T>::Delete(), which work with SystemHeapAllocator and are meant to
replace NewArray<T>() and DeleteArray<T>().

Array allocation using Array<T> and SystemHeapAllocator works in the same
fashion as the new[] and delete[] C++ operators in GCC: Enough space for
a size_t is overallocated, and the size of the array is stored as the
first element, then the actual elements follow:

		   .---- returned pointer
		   |
		   V
	    .------+--------+--------+-----+--------.
	    | size | item 1 | item 2 | ... | item N |
	    '------+--------+--------+-----+--------+

On array creation, constructors for the contained items are run (by using
the global placement-new operator); and on array deletion, destructors are
run as well.

However, for simple types (pointers, integers and floating point numbers)
it is enough to initialize the memory by zero-filling it, and destructors
do not need to be run. Therefore, tracking the number of elements in the
array is not needed. For those simple types a specialization of the Array
template is provided. Determining which types are simple is done using an
auxiliar IsSimpleType<T> template.
Convert {New,Delete}Array to Array::{New,Delete}
Add SystemHeapAllocator to public API

The SystemHeapAllocator structure contains callbacks to be used to allocate
memory from the system heap. The allocation is to be done by default using
the functions from the C/C++ library (e.g. malloc/free).

The v8::Isolate::New() function receives a SystemHeapAllocator pointer, and
all the memory allocation from the system heap done by the newly created
Isolate (and the Isolate instance itself) will be done using the callbacks
in it.