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.