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

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.