Refactor CStruct a bit.

- StructBase is now a module that defines member methods for structs on
  inclusion in a struct class. So, first the constants for the class
  must be defined, then StructBase is included.

- long_inspect/long_inspect= are now a class methods of CStruct, as this
  didn't really fit StructBase's role anymore.

- Memory is now the base class for all struct classes. This makes more
  sense than having a base class that could be instantiated, resulting
  in strange code.

- Member method definition of struct classes is now handled by
  StructBase::define_member_methods.

- Struct class generation is handled by CStruct::build_struct_type,
  which now acts as a secondary form of creating a struct class (though
  it doesn't call add_type like CStruct::new does).

- Array class generation is handled by CStruct::build_array_type. This
  method shouldn't be called - ever - by user code since it's already
  called by build_struct_type.
Rename encoding_for_members to decode_member_info, add encode_member_info.

I figure the process should be reversible, to an extent. It's not really
possible to recreate the exact same encoding string because bits are
optional, but it is possible to create an equivalent encoding string, so
that seems like a good enough plan.

As such, CStruct::new no longer does the decoding, it's merely calling
decode_member_info to decode and handing that off to build_struct_type.
Refactor arrays a bit more.

Most struct array methods are now defined under StructArrayBase, with
the allocator methods defined under its Allocators module.

On inclusion, StructArrayBase simply extends the including class with
the allocators to make sure allocation is handled as expected.
Move struct type allocators into StructBase::Allocators.

This is in line with the array refactoring done previously. Also moves
array type creation back into the Class.new block for the struct type
and makes realloc! private for structs, as there's no really sane
reason for realloc! to be available for a single object.
Add comment denoting end of MemberInfoSupport module.
Have com_malloc raise a NoMemoryError if xcalloc fails.
Raise a RuntimeError if com_free is called with a NULL pointer.
Remove object tainting.

After discussing it on #ruby-lang, it looks like tainted status is
mostly useless for security and $SAFE is mostly broken as hell, so I'm
not going to waste cycles on it.
Rename 'new' to '__wrap__'

new and wrap are now aliases of __wrap__. I figure this follows the
logical progression of things better than it did before, since 'wrap'
and '__wrap__' originally came out of a need ot override one after the
other, so '__wrap__' became the one that shouldn't be overridden.
Rename malloc to __malloc__ -- reverse order.

malloc now an alias of __malloc__ rather than vice versa. Again, helps
show the order of importance here.
Update sd_memory_new docs to match new default method name.
Update __malloc__ docs to reflect names.
Add sd_memory_force_free and sd_wrap_memory functions.

The former is simply sd_memory_free sans checks, the latter is more or
less what sd_memory_new/malloc do when returning a value.

Both sd_memory_free and sd_memory_new/malloc will have some bits of them
replaced with these. The latter function in particular allows me to more
easily add new functions that return memory objects.
Make use of sd_wrap_memory in sd_memory_malloc.
Make use of sd_wrap_memory in sd_memory_new.
Replace guys of sd_memory_free with sd_memory_force_free.

This doesn't do too much different right now, though it'll be important
if I need to later free memory from multiple sources and don't want a
frozen check.
Add alloca for stack allocations.

As mentioned in the rdoc comments, this is disabled unless explicitly
enabled with --allow-alloca.

Essentially, this just lets you create a chunk of memory on the stack,
do some stuff with it, and then dispose of it just as quickly. It's not
great for security and probably not very useful for performance seeing
as you're already using ruby and so any performance benefit that you
might get is already negated by the checks I do to ensure everything is
kosher. Still, who knows, it might be useful for allocating something
and changing it many times (maybe to copy it to heap, who knows).
Add --allow-alloca install flag.
Add HAS_ALLOCA constant to Snow::Memory.

Simply checks whether __alloca__ is available. If it is, aliases
__alloca__ to alloca, otherwise it's not available.
Move StructBase and StructArrayBase into their own files.

This should keep things a little cleaner in c_struct.rb

Also adds alloca overrides for structs and their arrays.