Add rewrite support for calls which use keyword args

Test against an old 0.5-series version of sqlalchemy

Use callattr inside PyObject_CallMethod*

After much investigation, I think this is the best option for now.
We might need to patch sqlalchemy or switch to refcounting.

The issue is that there's a dangling cursor that's left open, and
under cpython it will get closed quickly.  But for us, it's left open,
which keeps the connection open.  This leaves the table its referencing
locked.  But only in old versions of sqlite!  Newer versions are smart
enough to know that 'select current_timestamp() from table' does not
need to lock the table, so even though that select statement is still
running, it doesn't end up locking the table.

PyPy has a different issue with the test, where it closes the cursor too
early (not sure why).

Use travis_wait to workaround the no output received error

Add more Rewritable template args to functions

           django_template3.py             2.7s (4)             2.7s (4)  -0.3%
                 pyxl_bench.py             2.3s (4)             2.2s (4)  -4.1%
     sqlalchemy_imperative2.py             2.7s (4)             2.6s (4)  -1.4%
                       geomean                 2.5s                 2.5s  -2.0%

This exposed some other issues for us.

microptimize callFunc() by only calling getFunctionName() when necessary

even though getFunctionName() is fast it showed up in the profiler because it get's called very often,
but most of the time the actual value is not used.

use a template to remove rewriter checks inside our most important runtime funcs

when we know that the rewrite_args are NULL

                                origin/rewritable~:   origin/rewritable:
           django_template3.py             2.7s (4)             2.7s (4)  -1.3%
                 pyxl_bench.py             2.2s (4)             2.2s (4)  -1.7%
     sqlalchemy_imperative2.py             2.7s (4)             2.6s (4)  -2.4%
                       geomean                 2.5s                 2.5s  -1.8%

Add more asserts to aggressively enforce return conventions

You can't get the return value from a RewriteArgs without
looking at the return convention.  Debug mode will check the
return convention during the execution of rewrites.

Split "VALID_RETURN" into "HAS_RETURN" and "CAPI_RETURN" since some
places used it to mean either.

Hopefully this helps keep things clean.  There are a lot of places that
were implictly assuming a certain return convention, but now that they
have to explicitly assume it, the issues are more obvious.  Plus
they will get checked in the debug builds.

Also tried to fix things up while going through and doing this refactoring;
I think I found a number of issues.

add m2crypto test + fix missing stuff

IsType fix

Add a check to make sure users don't request custom __builtins__

I'm not quite sure what they're trying to use it for, but it looks
like it doesn't really do anything.  And we're no worse off with the
patch+assert than simply ignoring the behavior.

Fix registerDataSegment error when encountering symlinks

the /proc/maps entry contains the absolute file path with resolved symlinks,
this patch retrieves now the absolute path of the lib and resolves symlinks.

Add "pyinotify" test, with a minor modification to Pyston

We don't support that, and hopefully we don't have to.  CPython seems
pretty inconsistent about it and PyPy doesn't support it.

Ellipsis implementation

type.__getattribute__ and object.__getattribute__ are different

- oldstyle classed don't add __bases__ and __name__ as attributes to their dict instead the intercept them with __getattribute__
- it was possible to encounter a crash when importing a module and then deleting the entry from sys.modules and calling the function from the other module
- add a Pyston specific PyCode_GetArgCount instead of directly accessing code->co_argcount

- allow list subclasses to add __init__ functions that take more parameters
- support `[dict] == [attrwrapper]`
- fix bug in my recent weakref change

Calling object.__getattribute__ on a class will skip the normal
special type attribute-lookup rules (checking base classes, executing
descriptors).

make platform test pass