some minor NumPy fixing

Fix remaining "check refcounting" assertions

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.

this uses a slightly modified version of cpythons free list.
I removed the special handling for the empty tuple and fixed some C/C++ type mismatches.

checkAndThrowCAPIException needs to do a 32bit comparison in some cases

this should fix a very annoying rarely encountered issue...

check return value instead of calling checkAndThrowCAPIException()

this should make pyston more robust to cases where the error is set by a previous operation

no functional change intended

refcounting changes for our integration tests

Otherwise old build directories will switch to not having refchecking.

this fixes and reenables some of our integration tests

this gets triggered by M2Crypto which sets an error but returns None.
previously we throw the error in the non rewriter path and ignored it in the rewriter.
this makes it now identical and mote like cpython does it (only looks at the return value)

the fixed blocksize of our region allocator was too small for very large actions
fix this by using the more powerful llvm::BumpPtrAllocator which handles allocation larger than the slab size

previously we checked if NDEBUG was defiend but this caused problems with extensions which modified this define

interpreter: mark created_closure as live variable inside yields

without this we would never traverse the variable and the GC would therefore be unable to destroy the generator

The issue with django was that it called object.__dict__.__get__(unicode),
which would convert object to dict-backed, and then our shutdown logic doesn't
support that case.

The shutdown logic still doesn't support that case, and there are other ways
to convert object's __dict__ to being dict-backed, so this commit isn't a full
solution, but it seems like something we should do anyway.

Try to reduce JIT time for the LLVM tier

I was worried we were in trouble since we don't always pass an owned
reference to any arguments filled via defaults, but for Python functions
this is fine since we will end up creating our own reference to it.
For builtin functions, we disallow changing defaults.