Previously it would have to call out to checkAndThrowCAPIException(),
which is quite a bit slower than what it now can do, which is directly
checking the return value.

Previously, we would just call these "conservative python" objects,
and scan their memory conservatively.  The problem with this is that
the builtin type might have defined a custom GC handler that needs to
be called in addition to the conservative scanning (ie it stores GC
pointers out-of-band that are not discoverable via other gc pointers).

We had dealt with these kinds of issues before which is why I added
the "conservative python kind", but I think the real solution here is
to say that to the GC, these objects are just python objects, and
then let the type machinery decide how to scan the objects, including
how to handle the inheritance rules.  We were already putting
"conservativeGCHandler" as the gc_handler on these conservative types,
so let's use it.

Refactors on types of GC objects

Instead of GCKind::HIDDEN_CLASS, use GCKind::RUNTIME and require that
the runtime objects have a gc_visit functions by inheriting from
GCAllocatedRuntime.

rewrite float comparison base on CPython implementation

microoptimizations

rewrite additional nonzero() cases

- improve bool and str hash() speed
- optimize str.find(char)

Use profiling to know when to throw CAPI exceptions

Rewrite string hash and enable test_hash

if we OSR out of a function, make sure we use the same exception
style for the OSR'd version.

We could also have the OSR exit code deal with switching exception
styles, but for now it doesn't feel worth it.

Enable validation of printf-style format strings

I had added the ability but forgot to turn it on.

And fix some of the issues that this found.

Also, allow reraising using CAPI exceptions.

Clean up our exception handling

I use like to use test/tests/t.py and t2.py as temporary test files,
so that they can get hooked into the makefile helpers, but the tester
ignores them.  Do this for t3.py too.

It was pretty unwieldy and handled some disparate parts of the
exception-raising process.  I think things are a bit cleaner now:
- cxx_unwind.cpp handles C++ unwinding semantics
- unwinding.cpp converts C stacks to Python stacks
- exceptions.cpp takes Python stack frames and handles them appropriately

So for throwing a C++ exception, it starts out in cxx_unwind.cpp, which
then hands off the C frames to unwinding.cpp, which then hands off the
Python frames to exceptions.cpp.  When we get exceptions not via uncaught
C++ exceptions (ie explicitly handled C++ exceptions or CAPI exceptions),
those go directly into exceptions.cpp.  There are also non-exception cases
that we want to get the Python stack trace (ex sys._getframe), and those
are handled by unwinding.cpp

We have a couple different ways of walking the C stack
(C++ exception unwinding and non-destructing stack crawling),
and they both want to do this to reconstruct the Python stack.
Extract out the common code.

It had gotten pretty ad hoc.  There were two things it was doing
- some things dealing with unwinding; moved those to codegen/unwinding.cpp
- most of our exception-throwing logic; moved these to a new runtime/exceptions.cpp

Be able to jit functions that throw CAPI exceptions

In theory should help with pyxl which throws a decent number
of StopIterations from calling generator.next() directly, but
pretty few of those calls actually make it into the llvm JIT
to benefit from this.

(Not enabled yet)

Our IR doesn't explicitly represent the data transfer between an Invoke
statement and its corresponding LandingPad.  We use a couple different
techniques to pass it through: in the ast interpreter/bjit, we stash it
into an interpreter-local variable and then pull it back out.  Previous
to this change, in the LLVM tier we would pass it directly through
an exception, using either the C++ or CAPI exception-passing mechanism.

This works but is a pain, since it requires coordination between the invoke
and the landingpad.  These live in different basic blocks, so we ended up
having this other code that lives separate from the normal irgen that has
to decide which exception style to use, and it has to respect certain
restrictions within irgen (ie it has to be careful to not request CAPI
exceptions for cases that we haven't added support for yet).

This commit changes the approach so that the exception data is passed
directly as LLVM Values, and its up to the Invoke to figure out how
to get it into that form.  This adds a bit more complexity to the invoke,
but it should make the interface easier to extend (such as in the next commit).

Which piggy-back on the integration tests for getting their dependencies.

fix a few generator problems