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**.

It's easier to tell the two constants apart if they are different.

They tends to time out or just make the test suite run for longer. They definitely times out
when running a prototype moving gc.

Scan constants written into compiled code.

A GC could happen during the rewrite.

Scan rewriters for interior pointers

We need to do this because the ICInvalidator pointers are stored inside
Pyston heap objects.

Some improvments that let test_index could pass

Sqlalchemy compatibility fixes

Sqlalchemy subclasses set, and overrides __init__ and does some
custom initialization there.  We were doing the initialization in
__new__, which works most of the time, except if a generator was
passed since then sqlalchemy's initialization will see what looks
like an empty generator since we already consumed it.

So move the initialization to init.  Except for frozenset which still
needs to do it in new.

In CPython, str.add directly throws a TypeError since it is implemented
as a sq_concat.  sqlalchemy relies on being able to do str()+MyStr() and
use MyStr.__radd__ to handle the addition.  We were throwing a TypeError
but not implementing it in sq_concat.

So instead, return NotImplemented instead of directly throwing a TypeError.
This makes '+' more compatible but str.__add__ a bit less compatible.

add _PyLong_Copy implementation, return a copy in PyNumber_Long if the type of argument is long or long subclass

Add override keyword where necessary.

Generate better module names to make the object cache more effective

add tp_nextiter implementation for our iterators

one of the problems were that depending on if all files were all ready parsed we JITed more or less functions,
this changed the total number of jited functions which changed all the module names.
This lead to the result that in order to have all entries inside the cache we needed at least 3runs if the pyc files were old.

The whole name scheme should add some point get improved but for now it should be enough.

Lower initial dict/set size from 64->8