Where we hadn't gone through and updated the exception-catch
sites to clear/hand off their owned ref appropriately.

Mostly, what happens if class-creation fails.

add refcounting annotation to some set function

ie something like "print C().__dict__"

The attrwrapper objects don't (arnd probably shouldn't) keep their underlying
objects alive.  Previous to this commit they would just try to access their
freed underlying object and crash.

With this commit, object deallocation will check if there is an attrwrapper,
and if so convert it to be privately-backed.

First, our implementation of slot_tp_del (what calls Python-level __del__ methods)
was pretty bad -- it didn't re-incref the object to keep it alive.

Then we had some issues around running destructors at shutdown.  I made this section
look a bit more like CPython's, but there are still differences.

int positive function refcounting fixing

add refcouting annotation to zip builtin function

ie relax an assertion that doesn't quite check enough anyway.

Represent decref/xdecref operations as opaque functions calls.
I think the ideal solution would be to add a custom llvm intrinsic,
but I spent a small amount of time looking into that and had trouble
figuring out how to do that.

So instead, just emit them as patchpoints, and then patch them afterwards
with a fixed code sequence.

This commit only does this for decref/xdecref because:
- they occur much more frequently
- they are much more expensive to jit since they involve control flow
- forcing the op to fit a C-calling-convention isn't that much overhead,
  since the register allocator probably would have done that anyway due
  to the (potential) dealloc call.

I copied subtype_traverse and subtype_clear from cpython but
didn't update them to support our hcattrs

- fix instruction encoding of: add imm, mem
- fix Py_REF_DEBUG when increfing multiple times at once
- add missing bjit annotations

small refcounting fixing in tuple

I think they were timing out before

For use on the exception path.  Rather than emitting the instructions
for a bunch of decrefs, instead just emit a single call to xdecrefAll()

Improves performance quite a lot: sre_parse_parse llvm instructions goes
from 360k to 80k, and it's 60k if I manually disable cxx fixups.
Overall time [which is entirely compile time] goes from 12.5s to 4.4s,
though master does it in 1.3s so there's still some work to do.  But
even if I turn off cxx fixups entirely it still takes 2.9s.