Add support for using the CPython parser

That file doesn't have an include guard so it's tricky to get it working.

Not the actual memory blocks in it, but just the main metadata
object.  It contains pointers to other python objects; we could
potentially remove those pointers (looks like they are just for
reference counting) but for now just conservatively-allocate it.

Tricky since we need to open a pseudotty to get the repl behavior.
(Piping in a program to stdin goes through a different code path.)

pyxl_bench allocation reductions

rewrite instance_setattro

LLVM tier: adjust num of IC slots depending on the num of times the IC got rewritten in the bjit tier

LLVM tier: adjust num of IC slots depending on the num of times the IC got rewritten in the bjit tier

Avoid creating most slice objects

Module-level functions go through a slightly different code path than class-level
ones, so this commit adds the METH_O3/METH_D3 calling conventions to that as well.

Some stuff to enable "test_set"

We've been allocating slice objects for slicing operations, but
CPython's internal slice methods already take separate start+stop
arguments.  So if we see a slice, instead of creating the slice
and sending it off to getitem, try calling PySequence_GetSlice.

This will be slower for classes with user-defined __getitem__
functions that can handle slices; we can fix that by adding rewriting
to this new endpoint, but it seems to not matter too much right now.

Cleanup the __str__, __repr__ support and let they handle unicode strings

This converts a lot of -(int) into (-int)

typeLookup: guard on tp_version_tag instead of mro

For types which don't have Py_TPFLAGS_HAVE_VERSION_TAG set we keep the old behaviour

object cache: hash IR before running any opt passes

Remove an old assert

Remove unneeded pyston workarounds + fix misc cpython test errors 

Reenable unboxed values

add list self assignment and list.index with non int args
add thread._count
copy over test_urllib2 from the correct python version

This lets us to skip running the opt passes when we find a cached object file.
This has the disadvantage that opt passes are not allowed to call embedRelocatablePtr()
but has the advantage that we could do more costly optimizations in the future without hurting the perf on the second run.