Match cpython's HEAPTYPE flag

It's supposed to mean "whether this type is heap allocated", but
it gets used as "is this a builtin/extension type".  We heap-allocate
our builtin types so we were setting HEAPTYPE, but this keeps on
causing issues.  I don't think anything actually uses HEAPTYPE to mean
it's on the stack or heap, so let's just set them all to be HEAPTYPE=0.

For better or worse, I ended up implementing this by changing the builtin
types from BoxedHeapClasses to BoxedClasses, which seems to make sense.
This had the effect of changing the existence of the tp_as_foo structs,
which get automatically created for HeapClasses but not for non-heap classes.
So most of the changes in this commit are trying to make sure that we
have those when CPython has them.

Get more of the sqlalchemy tests working

so object's can be resurrected even with a non-resurrecting
tp_dealloc.  The only thing that can happen at that point is
that the gc_visit function will get called.

This shows up in the new sqlalchemy tests: they use a subclass
of dict (defaultdict), which defines a custom tp_dealloc.  We call that,
which ends up calling dict_cls->tp_dealloc, which calls ~DenseMap
on the internal DenseMap.  The GC will accidentally keep the object
alive (via a stack reference or something similar), and call its
visit function on the next GC.  But ~DenseMap does not leave the map
in a consistent state, so iterating over it will end up producing
garbage values.  To solve this, add a new function that does
all the same memory-freeing, but does a tiny bit of extra work to keep
the DenseMap in a valid state for future gc_visit calls.

More set stuff

__new__ is supposed to become a staticmethod

Enable the "mmap" module

symmetric_difference, in-place binops, etc

by expanding our test harness to be closer to how the tests get
run under pytest (which we don't support yet)

Also fix a couple minor things that this turned up.  There is a lot more
to be found here: the new harness supports many more of the sqlalchemy
tests, a number of which aren't working for us.  Also there is some
sort of issue with the current tests that we run, since repeating the tests
multiple times will end up crashing.

Signed-unsigned comparison giving bad results for the comparison.  Should probably
turn -Wsign-compare back on.

This seems to not matter very much, but it means that
Cls.__new__ is a the original function, instead of an
unbound instance method.

Fix set comparisons

Allow changing the number of default arguments

We already supported changing the values, but not the number
of them.  The main trickiness here is
- We had been assuming that the number of defaults was immutable,
  so I had to find the places that we used it and add invalidation.
- We assumed that all functions based on the same source function would
  have the same number of defaults.

For the first one, I found all the places that looked at the defaults array,
which should hopefully be all the places that need invalidation.

One tricky part is that we will embed the num_defaults data into code produced
by the LLVM tier, and we currently don't have any mechanism for invalidating
those functions.  This commit side-steps around that since the only functions that
we can inline are the builtins, and those you aren't allowed to change the defaults
anyway.  So I added a "can_change_defaults" flag.

For the second part, I moved "num_defaults" from the CLFunction (our "code" object)
to the BoxedFunction (our "function" object), and then changed the users to pull
it from there.

Implment some PyNumber_XXX function, to enable "test_operator"

PrintVisitor: use raw_ostream

Implement some PyNumber_XXX function, most of the code are copy from CPython with some Pyston changes

Type system fix: need to add unpacking to the type system

Used a hardcoded CXX exception style in the non-rewriteable case.

ie concerning things like:
  a, b = 1, 2

The irgen phase already knows how to do unpacking in a type-analyzed
way (a and b will be of type int), but type speculation needed to
have that added.

rewrite oldstyle class getattro

Optionally move objects around in memory to prepare Pyston for a moving collector.

Last few fixes to make sqlalchemy_declarative work

This will reallocate all objects in the small heap and update
all references that were pointing to this object.

This is not functional yet, there are still references that we are not
tracking at other points in the program, so it's still gated behind the
MOVING_GC flag.

- Refactor the stack logic into a separate data structure ChunkedStack,
  keep the push function that deals with marking as functionality specific
  to a subclass of ChunkedStack (no virtual, just reuse code).
- Add an additional (disabled) phase that maps out the reference graph
  reachable objects after the sweep phase. Prepare moving all objects in
  the small heap.

Also, rename TraceStack to TraversalWorklist because the fact
that we're using a stack is an implementation detail.

Moving gcs will need this to update pointers. There should not be any
extra dereference, it will just happen on the other side of the
function.

Use templates to avoid direct (void**) casts -- make sure we're always
passing an pointer of the form T**.