We weren't properly reducing the stack depth when yielding from a generator,
meaning that the recursion depth was effectively decreased by the number
of active generators.

Too many things want this to be able to remove it completely.  Surprisingly,
having imp.get_magic exist but return a changing value seems to make all those
libraries happy.

A function at risk of "naive misuse", it is only accessible via the C API.

This commit adds basic support for it using the same mechanism we use for
signals.  We also have the GIL-check mechanism, but that would be a bit more
work to get working right now due to the fact that our GIL-checks don't support
throwing exceptions.  Doing the async-exc check during signal checking means
that we will throw the async exc faster than CPython does.  It also means
that there are some pathological cases where with a lot of threads and a lot
of async excs we will probably have much worse performance.  But as long as they
are rare I think this commit shouldn't add any steady-state performance costs.

Specifically, for the case that locals==NULL (which Cython exercises), which
wasn't previously working.

now using ctypes to test the c api

We fast-pathed "type has __init__ but not __new__" by saying
that the default __new__ would always succeed, but this isn't true for abstract classes.

Add test for typing.py and fix the issues it uncovers

Otherwise they would inherit object's __doc__

Update lz4 to a version compatible with gcc 4.9+

Not 100% sure of the reason but lz4 gets mis-optimized (or "has UB"
depending on who you ask) in the version that we're using, so update
to a version that has a fix.

Make these properly CAPI functions

Change section memory manager to fix performance problem in long-runn…

remove RODataMem.FreeMem.clear(); and replace return true to RELEASE_ASSERT(0, "finalizeMemory failed")

Add type.__instancecheck__ and __subclasscheck__

We supported classes that overrode them, but didn't provide a
default implementation in case people called it by hand.

The tricky part is making sure that these new additions don't
mess with our "does this class override __instancecheck__" optimizations.

Fix docs about stats option

Take a pass over the CPython tests

and only run the small variant in debug mode to avoid timeouts.
Previously I had tried splitting it in half, but it looks like that's
both not enough to avoid timeouts, and it also has a race condition when
trying to run two copies of the test at the same time (one will read the
not-fully-written pickled output of the other).

Two of these tests pass in release mode but not in debug (one is a timeout, the other is an assertion)
Two of them are failing in both and I don't know why I marked them as succeeding.

ie did some quick debugging and added test notes

needed because of how we symlink things

test_itertools was failing because of a version mismatch between the test and the implementation we copied

For some reason the max-RSS limit doesn't seem to be kicking in.
Switch to putting a limit on the virtual size instead, and bump the
limit from 500MB to 1.5GB.

to not conflict with CPython's -O.  They're quite similar
(increase optimization level), but some tests ask for -O when
they don't really want our version of it.

Main difference is lowering the recursion-depth on unoptimized
builds, since we need more stack space per python frame.

We symlink the CPython tests into our tests directory to control which
ones we will attempt to run.  A bunch of the tests though need other
test files in order to run, and we hadn't symlinked those in.

At some point we should switch to symlinking the Lib/test directory instead
of individual files, but for now this helps.