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.

Copy tp_as_number *after* commonClassSetup

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

make `int("some_random_string")` faster

Probably more compatible, but also much faster.

Also, set str_cls->tp_repr.

We currently over-build it quite a bit; I'll try to look into that
issue, but for now we can lessen the effects by at least building
it in parallel.

Allow string + bytearray => bytearray. Fixes #780

improve getattr() speed

We're keeping them around anyway

Our exception throwing is still slower than CPython's, and it looks
like it's partially due to the CAPI calls we do as part of the throwing
process.  For example, we have to actually create an exception object,
which involves calling the exception type constructor, etc.  We could
try to jit this stuff, but for now add another fast-path to typeCall
that should catch some of this.

Also, add a fast-path that inlines most of the exception-creation behavior.
Looks like this isn't too much faster than the above-mentioned fast-path.

Remove __attribute__((__malloc__)) from the gc

support yield statements inside lambdas

This attribute unfortunately lets the compiler skip stores if
the pointer doesn't escape.  This is bad because we will be
looking at the memory during a collection; the compiler was skipping
storing to cls and then the gc was crashing.

Have pypa parse strings directly

Save the key hash in dictionaries