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.

- Change INT to a type that remembers whether it was boxed or not.
- We still need a way of specifying a plain unboxed int, so add a
"phony" UNBOXED_INT.  UNBOXED_INT is not usable as a variable type,
but can be used to specify argument and return types.  It's up to
the receiver (irgen or type analysis) to convert UNBOXED_INT to
a usable INT.  Right now that's only guarded with a number of
asserts (and not through, say, the C++ type system).

This will fail even with the current workaround

Add cpythons method cache

Fix a rare 'assert R11 is not used' crash

disable moderate opt and pyston passes and increase reopt threshold

Add module "readline" and update CPython test notes.

handle the situation which provide a directory to pyston

My sym entry llvm stackmap patch contains a bug where it will emit stackmap entries with the wrong offset into the large constants array.
The problem is that the code assumes that the symbolic stack map constants are emitted at the end of the constants array,
but doen't take into consideration that "normal" large constants can be added after symbolic entries.
Thereby making the assigned offsets point to the wrong constants.
To fix this issue I'm calculating the offset for symbolic entries now at the very end when we know that the number of constants can't change anymore.
A nicer fix would be to not emit the symbolic entries inside the large cosntants array but instead into a special one.
But I think this is overkill for now and would like to todo this when the stackmap v2 code landed inside llvm in order to not have to implement it twice.

Try to fix "enforce return conventions" perf regression

Misc perf improvements

Pending review: add __call__ attribute to builtin functions and methods

We can rewrite a callattr where the getattr was done via a getattro,
if we are in CXX mode.  This got lost in the "enforce return conventions"
PR and resulted in a 4% slowdown on pyxl bench.

I think it's because the initial allocation of it fails.  This only shows
up in the debug build of lxml_test, which doesn't get tested through CI.

Add rewrite support for calls which use keyword args