Add support for weakref.proxy

Add support for specifying the encoding inside source files.

Support for inspect.isgenerator, round(int), property.__doc__

Sqlalchemy tests

Apparently the 'assert' statement works by looking up the "AssertionError"
name in the global scope, and then raising an exception of that type.

pytest uses this to override assertion behavior.

By replacing the entry in sys.modules.  pytest does this.

This was preventing subclasses of module from overriding __init__.
Yes, that really happens.

sqlalchemy uses pytest to run its test suite, which unfortunately
has been hard to get working.

I had to change 'new_weakref' to use 'tp_alloc' instead of 'PyObject_GC_New'
in order to create a weak ref because 'PyObject_GC_New' allocated memory
is scanned conservatively.
'tp_alloc' points to 'PystonType_GenericAlloc' and is of PYTHON type.

Ignore generated tmp folders.

visit im_class in gc handler

-m support

In particular this helps with our support for throwing
old-style classes as exceptions.

made the checks in CheckExact

zip() takes varargs. django passes 3 containers to it.

Fix speculations at module scope

Conflicts:
	src/runtime/objmodel.cpp

Closes #466

Add im_class field to BoxedInstanceMethod, implement instancemethodRepr

Add support for string interning

Handle map(None,...), exec with module.__dict__ as globals

Singleton hcls storage strategy

The storage strategy per-object is the same as NORMAL, but instead of having
immutable chains of hidden classes so that we can share them between instances,
a SINGLETON hcls is unique to the single object that it is for.  This means
that it can be mutable.

This has the advantage that we don't have to track all the parents
of the hidden class.  This is especially helpful since the cases that
it's used for (Python classes and modules) tend to have a large number
of attributes (>100 not uncommon).

We could also use the DICT_BACKED strategy for those cases, but compared to
DICT_BACKED, SINGLETON should have much better lookup performance since
it is patchpoint-compatible.  Adding new attributes is probably slower,
and deleting attributes is probably much slower, but I think those are
hopefully rare.

This cuts non-jit 'import pip' memory by 15%, from 113MB to 98MB.

Not only does this improve perfomance, but it somehow improves performance
consistency as well.

we could use this in much more places if performance and memory benchmarking shows it's an improvement.

import with globals

It's a little bit complicated due to the fact that
gdb has to be the parent so that it can have the permissions
to ptrace the process that segfaults.

imports apparently have to look at the globals scope in order
to determine how to handle relative imports and package references.

Sqlalchemy for some reason does this, and once we have this sqlalchemy
imports.