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.

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

Copy tp_as_number *after* commonClassSetup

Was a descriptor issue where we were interpreting 'None' as 'no argument'.
I think this only gets triggered when pip has to do a http retry, which is
why it only sporadically made the tests fail.

To specify the lack of the second argument.  This improves compatibility
when applying descriptors to the None object itself.

This was showing up since we were trying to call None.__format__

Add float_info to sys module, and rewrite version_info use SequenceStructure

This is important because commonClassSetup will modify tp_as_number
if it exists.  This causes an issue when an extension class uses
multiple inheritance; it will inherit the tp_as_number from its
main base, but then copy in any fields from its secondary bases. But
tp_as_number points to the same struct as its parent, so it would
update the parent's slots accidentally.

So, move the tp_as_number copying to where CPython does it, or at least,
after the calls to inherit_slots.

Add more __repr__ attributes to our builtins

Switch our Python set implementation to use a llvm::DenseSet

Microoptimize the rewriter class

Improve the float implementation, enable test_float