Just do it by putting a different class object on the same C-level structure.
Not too hard right now to defeat the frozen-ness, please don't try.

Ended up not being too bad, except for some more fun around classdefs
having different rules, and making sure to generate the correct error
type and messages.

Not worth producing CPython's error messages exactly: some delattr
messages depend on whether or not the object has a __dict__ allocated
or not.  Just canonicalize those in the tester.

Merges #101

Conflicts:
	src/codegen/runtime_hooks.h

Just convert them to ints and strings, failing if the conversion isn't possible.
Unicode and str are the same thing, right? :/

Oh, no this was the issue: we were writing out valid-looking but corrupt pyc files if the parser crashed.  Now leave the files as corrupt if the parser crashes

Before was throwing AttributeError, since we were just translating it to:
import a
b = a.b

Now there's a special importFrom runtime function that does essentially
the same thing, but throws the proper exception.

Now more resilient to truncated pyc files; got into a bad situation
where the parser crashed, wrote out a half-pyc file, which wasn't
judged to be invalid.

Previously, a non-satisfied except filter would cause the traceback
to be lost, since we were using the one-argument 'raise exc' form.

For os.py.  Currently just do it by inspecting the set of modules
at the end of the runtime setup; CPython does it by examining the
"import inittab".

Required adding str comparison methods so they can be sorted.

bonus: add errno module.

The python stdlib apparently uses a bunch of old-style ways
of doing things.

Instead of doing the throwing directly in the generated IR, call
a runtime function raise1 which will take care of the semantics
of checking the type of the raised object, etc.

Ie if a class is defined in a function, and that class contains
a function which references variables from the enclosing function,
previously the classdef would not pass the closure through and
things would fail.

Now classdefs (and other scopes) can pass through closures even if
they don't add their own variables to the closured-set.

Also, fix some bugs along the way.

Before we would write all local names into the class dict;
this is close, but was including undefined names.

Have to get help from the IR generator to determine the live names,
so add a LOCALS opcode (CPython has a similar one), and use that to
generate the dict that a classdef returns.

The current support is not quite enough to support the locals() function,
since even though we have that information available at the IR generator,
it's not easy to make it available to the runtime.

thanks Marius for the report

Before it was part of the (type-agnostic) AST-walker, which didn't make sense.

Not sure how these didn't show up before...

Fixed a bug causing unit tests to fail in my installation

Fixed a bug causing unit tests to fail in my installation: the declaration of runtimeCall in stdlib.bc had a different name in place of `class.std::vector`, so looking the type up by hard-coding its name results in a type error when the instruction calling `runtimeCall` is constructed.

Implement lambda expressions

Conflicts:
	src/codegen/irgen/hooks.cpp
	src/codegen/irgen/irgenerator.cpp

Conflicts:
	src/codegen/irgen/hooks.cpp
	src/codegen/irgen/irgenerator.cpp
	src/core/types.h

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