This commit works by adding a SmallFunction class that behaves
like std::function, but allocates its data inline rather than through
a separate allocation.  It probably could have also worked by taking
a custom allocator and using the new RegionAllocator.

It adds a bit more restrictions than std::function does (the types
caught by the closure have to be more "trivial" than std::function
supports), so some of this change is marking some types as trivial,
or copying data into a trivial format from things that aren't (ex SmallVector).

ie a simple bump-pointer allocator that will release all
of its memory when the rewrite itself gets deallocated.

Not a huge help itself, since most of the mallocs have been removed
from the rewriter, except for the std::functions which don't take
a custom allocator (at least not in libstdc++ 4.8 [and 4.9 I think]).

Fix submodules

Somehow most of them did not make it in the second merge.

Undo testsuite split

Reduce allocations

Use adjustment-post division to avoid int division overflow

For some reason CPython allocates an extra "item" for generic
variable-sized objects, but it looks like it doesn't do that for
tuples.  We had been doing that, so let's try not doing that
and saving 8 bytes per tuple.

Reduces boxing during the import process

This is a temporary fix for the fact that "-1" is currently getting
parsed as "-(1)", which will cause us to call '(1).__neg__()' with
the associated overhead and allocation.

It should be useful even after that gets fixed though.

- Check for the allocation of empty tuples and just return the singleton
- Try to avoid creating the kwargs dict since it might end up being empty
- Let unicode-creation special case apply to all argument types
- Fix type(obj) to be fast again (got superceded by a different special case)
- Do fewer allocations in int()

Forgot to do this when I switched away from an StlCompatAllocator,
so we were leaking memory pretty badly.

more small exceptions optimizations

Actually, for now in all cases unless __init__ is a Python function.

- Add a has_subclasscheck class slot
- Add a fast path for when the exception matches exactly (though
  we have to check that there isn't a metaclass involved first).

The rest of our builtin types use our "hc attrs" (hidden-class-based attribute
storage), but we use the CPython implementation of exceptions which ask for
dict attributes.  So, expose our hcattrs via the C API and change the exceptions
classes to use it.

Hopefully we can eventually find some more general way of providing this feature
(ex for all string-keyed dicts) without needing these changes.

Mercurial fixes

Some misc small optimizations

descriptor/format fix

bjit: don't generate a 'getGlobal' call for 'None'

Some improvements for int to let test_int could pass

They had mistakenly gotten enabled because the name of the integration test
step was a superstring of the quick tests, so it matched the regex.

It had gotten to the point that a large part of the cost of throwing an
eception was allocating the std::string's to represent the function and
filename.

Most of the other strings have already been converted to being represented
as BoxedString's (ie python strings), so do that conversion here and a few
more places.

The callee had already but updated to take a smallvector, but
we were still instantiating it as a std::vector.

Call a combined new+init, and don't create an arg tuple just
to immediately slice into it.

Much faster than using pyElements into a std::vector<Box*, StlCompatAllocator>.

I think pyElements is pretty good, but the PySequence_Fast approach can beat it
since we do the entire conversion up-front, and don't pay the dispatching cost
per iteration.  Plus the STL-compat-allocator is just as expensive as a Python
list, and most of the time the extra storage isn't needed anyway.

Instead of relying on stack unwinding to find it.

add instanceTrunc to old style class, but not expose the API, just let instanceInt call it when the inst don't have __int__ attr