enable sqlalchemy_smalltest

I did not trigger this bug (also could not come up with a test) but just by inspecting the code I thought it's very suspicious.

But I did remove the assert(!exc_state.is_reraise) assert because it got hit in a legitimate case,
(c++ exception got rethrowen in the llvm tier, cought in our c++ code and rethrowen because of api mismatch. With no python code in between.)

Reenable the 'extra' tests

I don't know what the reason is, but it's tripping up cffi's test suite.

Extract the logic from DEFAULT_CLASS_SIMPLE

One small change for numpy performance

merge the missing merge commits (mostly cosmetic change)

so that it can be used in more places.  Looking at pyxl_bench2_10x,
most of the calls to PyType_GenericAlloc are from the dict and list
iterator classes, which don't use DEFAULT_CLASS_SIMPLE (or DEFAULT_CLASS)
since they use the same C++ class with multiple Python classes.  So
by extracting out the core of that function, it's now usable by those
other classes.

Also convert some things to DEFAULT_CLASS_SIMPLE while we're at it.

- support CPython
- don't blow away the checkout each time

Numpy was hitting this a lot

I love optimizing things we haven't approached before.  This small change
improved numpy.test() performance by 20%.

some minor NumPy fixing

Fix remaining "check refcounting" assertions

Conflicts:
	src/codegen/compvars.cpp

Remove numpy submodule

clone numpy with 1.11.0 tag from github,
and adjust the numpy test file.

Some misc performance optimizations

They were all in code that is now dead, so I spent some time
verifying that and cleaning it up.

Make rearrangeArgs take a callback instead passing back values

thanks Marius for the tip

add tuple free list and don't update boxed frame on exit when it's not used

My hunch is that code density is more important than avoiding
ome of the `if (rewrite_args)` checks.

Also add some hacks to get rid of the func-name-getter-as-lambda,
so we don't need to templatize on that either.

Results of this commit are kind of mixed:

       django_template3_10x.py            13.6s (2)            13.8s (2)  +1.4%
 sqlalchemy_imperative2_10x.py            18.8s (2)            19.0s (2)  +1.2%
            pyxl_bench2_10x.py            10.7s (2)            10.1s (2)  -5.1%
                       geomean                14.0s                13.8s  -0.9%

And add an optimization that in the fast paths, we don't incref any args.

This function is complicated because it has so many return values (out-parameters).
It also returns a decent amount of information about what the caller has to do
after it is done with the args (decref them, decref the rewritten ones, etc), and
the contract was getting very complicated.  It also had some complicated rules
about how the caller had to set up certain input arguments.

I also tried adding some optimizations to it, where it would sometimes not incref all
of the returned args; I tried continuing the current scheme by passing back some information
about which args needed to be decref'd or not.  This was really messy and was also a
perf hit.

So instead, switch it to being callback-based.  I think this should clean it up quite a bit
and also open up some room for more optimizations.

This commit is just a refactor -- it changes the name to rearrangeArgumentsAndCall, which takes
a "continuation" callback.  For now it just calls rearrangeArguments under the hood.