This adds quite a few C API functions
and I had to introduce atleast two temporary hacks:
- do not depend on the ABC module which uses weak references
- use a dummy PyErr_CheckSignals() function

in regards to how the metaclass gets picked.

'buffer' is currently just an empty class.

add weakref support for user defined subtypes (with inheritance) and 'type' instances

There are some times that the importing logic has to look up attributes
on objects, and we were using Box::getattr() (equivalent to
obj.__dict__[attr] ) instead of getattr() (equivalent to getattr()).
This was working fine until we started trying to run the custom import hook
in six.py, since that creates a subclass of ModuleType which defines
some of the important attributes as class-level attributes.

We apparently never tested compiling from_cpython files
with gcc, unless you manually passed USE_CLANG=0 which I
doubt anyone did.

Add a pyston_gcc target that just defers to cmake's better
ability to use different compilers, and run the test suite
through that rather than just pyston_prof.  This gives us
better coverage and also allows the Makefile to fully defer
`make check` to cmake.

Also, fix a couple bugs that gcc exposed.

cmake ignore gcc warnings in from_cpython

-added -Wno-unused-result and -Wno-strict-aliasing for gcc 4.8.2 compatibility

There are still a couple subtle differences in how we track and
store the various module attributes.  For example, we show something
different for 'print ModuleType("a", "b")'.

Also sneak in a fix for "import a.b.c as c"

Add should_error directive, for tests that should exit non-0

runtime/inline add header dependencies

-fixes #339

The core functionality is to calculate and store tp_mro and tp_bases
instead of just tp_base.  This gives the runtime a bit harder of a
time to bootstrap itself since now a fully-built class depends on
a few more classes, so the bootstrapping section got larger:
- object_cls (base of the tp_base hierarchy)
- type_cls (base of the metaclass hierarchy)
- str_cls (for ht_name)
- tuple_cls (for tp_mro)
- list_cls (for calculating the mro)

There were a few places that needed to be updated now that we have
multiple inheritance:
- typeLookup()
- isSubclass()
- typeNew()
- super()

This change doesn't even attempt to add multiple inheritance rules
around old-style classes.

While most of this code is unexercised with just this commit, I wanted
to add it so that it's more clear what the multiple inheritance changes
actually are.

Our class-creation code is getting pretty unruly, since there
are four places we can create new classes:
1) extension classes
2) Python-defined classes
3) builtin-defined classes
4) classes created during bootstrapping

Then, there are multiple different sets of initialization functions
that can be called, each of which initializes different sets of the
class attributes.  It's not easy to tell what a given initialization
function should actually initialize.

This change just cleans this up slightly: it renames PystonType_Ready
to commonClassSetup to hopefully be more clear about its goal, as well
as adds a BoxedClass::finishInitialization() function.

It also moves some work out of the BoxedClass() constructor, since
this causes issues because it happens before the BoxedHeapClass()
constructor runs, which sets certain class slots that affect other
parts of class initialization.

Things are still pretty complicated but this should help with the
multiple inheritance changes that are coming.

add tests for "[] = []", "2 = 2"; currently we core dump on these

Implement `pyston -c command`