Add a new allocation type CONSERVATIVE_PYTHON for extensions objects, for which
we don't have heap maps, but should still have Python finalization semantics
(ie destructors and weakrefs).  Previously we were just marking them as
CONSERVATIVE and skipping them during the sweep phase, and not running destructors
or handling weakrefs.

It's a bit tricky to figure out when to mark an allocation as conservative vs
conservative-python; the approach in this commit is to mark all capi-originated
allocations as conservative, and then when we call PyObject_Init or PyObject_InitVar,
switch them from conservative to conservative-python.  I think this is more expensive
but safer than assuming that certain apis will always/never be used as object
memory.

Unfortunately there are quite a few extension classes that request a custom tp_dealloc,
and this commit just keeps the old (bad) behavior of ignoring those.  I tried to verify
as many as I could and they all seem benign, but it will be nice to have
real destructor support :)

Make our pyc handling more robust

Add __cmp__ and dictproxy

and add a pyc "stress test".

I think these issues are the source of our sporadic ci failures;
it makes sense based on where things fail (usually in the parser), and
because it's stateful (if you already have pycs generated you don't
run into the issue) and because it only happens in multithreaded mode.

changes:
- read the entire file at once, then do checks
- add a simple xor checksum in addition to the expected length

add libunwind_patch for binary search

StatTimer comparisons

Add pyexpat support

Some minor merge conflicts due to duplication with #544.

Faster version of attrwrapper.clear()

implement long.__pos__

Add a bunch of capi and fix a bug inside PyNumber_Int (was throwing a c++ exception)

It's no longer being used, and isn't safe to use any more
since it's not invalidated the times it needs to be.

Misc stuff

Generators: Support explicit StopIteration raising.

Before this patch we couldn't run 'list(G())' if G contained a explicit raise StopIteration statement.
This also adds support for custom StopIteration subclasses.

(was throwing a c++ exception)

unwinder

The signal-blocking is used to prevent libunwind from being entered
recursively, if a signal handler invokes libunwind. We don't call
libunwind from signal handlers, so this is not a problem for us.

The conservative checks just make crashes behave more nicely. They have
a small but measurable performance impact. We enable them in debug mode
and disable them for release mode.

We also modify .gitmodules so that our patches to libunwind/ don't make
git think the tree is dirty.