Improve isinstance speed

Make sure to intern attribute string in PyObject_SetAttr.

Handle the extensive edge cases related to sequence slicing

bjit: omit frame pointer + use R12 for ASTInterpreter*

isinstance(obj, cls) needs to do a bunch of dynamic checking: it needs to
check cls's class to see if it defines __instancecheck__, and it needs
to fetch __class__ on obj.  Most of those time those aren't overridden,
so __instancecheck__ gets skipped and __class__ returns the type of the object.

So use the same "type slot" machinery to cache whether an __instancecheck__
or custom __class__ attribute have gotten added.  These are a bit different
than the other slots since they are not "wrappers", they are simply bools
that say whether or not the attribute exists.  This makes the slot handling
code a bit messier / more divergent from CPython, but I think it still makes
sense to put this here since we get the hooking-on-attribute-updating and
update-all-subclasses-as-well automatically.

This reduces the number of stack access, because previously when we accessed a field of the interpreter
we always had to load it first from stack into a reg - and now we have a dedicated reg.
This is currently only a very small perf change but when #736 lands this becomes more important.

My theory is that specifying the separate cache directories
interacts badly with travis-ci.  I think it will either delete
any cache directories that look like they are no longer cached
(ie when it finishes the debug build it will delete the release
ccache dir since it looks unused), or maybe it keeps them around
but only checks the most recent build for a cache hit (ie the
debug build might check and only find ccache_release).

So anyway, try always specifying both directories.  Another
option is to do the simpler thing and use a single directory for
both caches, but I want to only change one thing at a time.

Slightly speedup ASTInterpreter::initArguments

Call finalizers during garbage collection with ordering

- Non-integer and non-None object passed into slices can fall back
  to item operator.
- Support indexeable items for slices when appropriate.
- Increase setitem and delitem ic slot sizes so that the rewriter
can succeed.
- Increase the performance of using slice operators on built-in types
  avoiding a lot of the guards and slowpath.

- Call either the item functions (e.g. __getitem__) or slicing function
  (e.g. __getslice__) to match the CPython behavior.
- Implement __getslice, __setslice__, __delslice__, for lists.
- Implement __setslice__ for strings.
- Some refactoring of common functionality for indexing and slicing.
- A lot of tests.

Make sure CPython functions like PyObject_Del do not free any objects.
It's better to let the GC free all objects because only the GC can
guarantee that there are no more references to an object.

New testing helper function ensures that objects are garbage
collected and their finalizers tested in a more strict order. This
reduces the chances that an object isn't collected because a reference
remains in the stack, but it's hard to fully solve this problem as long
as we have conservative stack scanning.

- Call all finalizers properly, in a safe-to-do-so order.
- Make finalizers work together with weak reference callbacks - namely,
  both should be able to get called, and weakref callbacks should be
  called before finalizers.
- Old style classes are also supported, but we always do an attribute
  lookup for tp_del because there's no tp_del slot. Since it would be
  too slow to do an attribute lookup all the time in GC, we just assume
  all old-style classes have an ordered finalizer.

Make sure __del__ methods get assigned to tp_del in new style classes.

Go through an attribute lookup in old style classes. Also, change the
function calling structure to match CPython's a bit better.

For exceptions thrown in tp_del methods, print a warning and ignore
them, like CPython does.

Fix parsing caching

Reenable attr interning

Flipped conditional meant that we were never caching the parse results :(

If we ask for a string as non-interned, and then ask for an interned
version of the string, we will discard the non-interned version and
generated a new interned version.  Now, keep the old version alive
as well.

From the course of debugging this gc issue.  this commit
shouldn't have much effect normally.

update libpypa

Add integration test for installing NumPy

travis-ci fixes

You can't use exit() to exit in the same way as if you had
died with a signal; we tried to do some exit-code munging
but we did it one way and our tester script expected another
way.  we could resolve that, or use the approach here: try
to die with the same signal by sending it to ourselves.