Not completely correct/working yet, but finally start
doing classes the right way.

Should probably give up on hacking it like this
and just handle classdef scopes for real.

Some basic fixes

(was previously only working at the global scope)

Pretty similar to #78

- find could not possibly have worked prior

(Though most libraries will probably crash)

Fix make check: Order includes alphabetical

Fix reversing of >, <, <= and >= compare operations

Just noticed that they are also wrong

Required a bit of refactoring in terms of how
parameter specifiers are passed around.

Well not sure if it's a deadlock; I think we try to
re-entrantly acquire the codegen lock, which then
confuses it later?

GC: Register None

Implement chained comparisons

Merges #88

Conflicts:
	src/core/threading.cpp

Not sure why greg_t got changed from 'long' to 'long long' in newer versions of glibc; just cast it to be compatible

Build fix

Signed-off-by: Vinzenz Feenstra <evilissimo@gmail.com>

Implementation is pretty straightforward for now:
- find all names that get accessed from a nested function
- if any, create a closure object at function entry
- any time we set a name accessed from a nested function,
  update its value in the closure
- when evaluating a functiondef that needs a closure, attach
  the created closure to the created function object.

Closures are currently passed as an extra argument before any
python-level args, which I'm not convinced is the right strategy.
It's works out fine but it feels messy to say that functions
can have different C-level calling conventions.
It felt worse to include the closure as part of the python-level arg
passing.
Maybe it should be passed after all the other arguments?

Closures are currently just simple objects, on which we set and get
Python-level attributes.  The performance (which I haven't tested)
relies on attribute access being made fast through the hidden-class
inline caches.

There are a number of ways that this could be improved:
- be smarter about when we create the closure object, or when we
  update it.
- not create empty pass-through closures
- give the closures a pre-defined shape, since we know at irgen-time
  what names can get set.  could probably avoid the inline cache
  machinery and also have better code.