The goal is to not continually call functions that deopt every time,
since the deopt is expensive.

Right now the threshold is simple: if a function deopts 4 (configurable)
times, then mark that function version as invalid and force a recompilation
on the next call.

Old deopt worked by compiling two copies of every BB, one with
speculations and one without, and stitching the two together.
This has a number of issues:
- doubles the amount of code LLVM has to jit
- can't ever get back on the optimized path
- doesn't support 'deopt if branch taken'
- horrifically complex
- doesn't support deopt from within try blocks

We actually ran into that last issue (see test from previous commit).  So
rather than wade in and try to fix old-deopt, just start switching to new-deopt.

(new) deopt works by using the frame introspection features, gathering up all
the locals, and passing them to the interpreter.

We currently can't deopt from inside an exception block.

You can imagine what happens if the variable is undefined and we
try to return it.

Mark enumerate_cls as safe for type call rewriting

The macros would cast to PyObject*, but our functions would just take a PyObject* --
which is an issue if the argument is something else (like a PyListObject*).
We need to have wrapper macros that cast and then call the underlying function.

Many of them originally failed due to a missing language feature,
but now were failing due to simple reasons like printing out the repr
of an object which doesn't define __repr__ and getting something like
"<C object at 0x1234567890>" (ie nondeterministic).

More gc perf changes

add a PRECISE and HIDDEN_CLASS GCKind, with special visit behavior (visitRange for PRECISE, and HiddenClass::gc_visit for HIDDEN_CLASS).  don't scan HiddenClasses or HCAttrs conservatively.

store frequently used values in the Block.  also give scanForNext an out from entering the loop at all

use a vector of chunks for the TraceStack, instead of a vector of individual pointers.

My theory is that this is because it overflows a signed int in
32-bit builds.  This should hopefully fix #272

Str just funcs

also keep a free list of chunks around to make subsequent collections faster.

results in TraceStack::pop and ::push being inlined and disappearing from the perf report (::push was at 3.99% before).

Also drops aggregate GC times for ray trace by ~5%.

before: gc_collections_us: 2151827
after: gc_collections_us: 2023809

Had to modify tempfile to not depend on io, which is a big module (due to importing _io).
tempfile seems to barely even use it, and I think I was able to replace its usage with
a simpler os.write call.

The signal module is Python code's interface to signal handling, but also the
way that the interpreter accepts and handles signals.

This commit just enables the first part, but things will crash if a signal
actually gets delivered.

Reduces slowpath_typecall from 40000 to 30 for spectral_norm

fixing #167: using gc allocator for gmp

Add a simple cache for runtime ICs

spectral_norm.py runtime improves by about 5%:
rewriter_attempts: 135109 --> 55133
rewriter_commits: 80138 --> 162
runtime_ics_num: 40003 --> 15
slowpath_binop: 82702 --> 2726

ie names that begin with two underscores but don't end in two underscores have
the classname added to them.

Do this early on in the pipeline so that all the analyses operate post-mangling.

The implementation is kind of hacky and I couldn't think of a good way to make it
super systematic; there may be more cases I missed.