reduce(), some float precision issues, string interpolation improvements

(more) correct semantics for import

I guess these will always be the same thing which is why it works,
but it's still wrong :/

Use call_done_guarding to defer the call to setDoneGuarding
until later.  As messy as it is, I guess this was the point of
the more_guards_after passing tha we had.

We'll have some issues with typeCall if the __init__ func wants
to set some guards too, since those will happen after __new__
was already called (too late for guards); we'd have to figure
out how to get __init__ to do all of its guards before calling
__new__.  (This applies even if we try to do it in multiple passes,
since we wouldn't have a "all guards before any mutations" flow.)

(which has flipped value)
should hopefully be more clear what this is for -- at least
I hope that's what this is for.

Also fix a GCC warning... not sure if this is supposed to be better though.

With a quick modification to get around the "import os.path" issue,
we are able to run go.py!

Not sure if it's better or not to have the "unicode"
name accessible, given that we don't support much
of its functionality at all.

For instance, sre_compile detects if "unicode" is available,
and if so, calls `type(unicode(""))` which will fail for us.

Conflicts:
	src/runtime/types.cpp

random_test.py is running into the same issue as _random_test2.py,
of the rewrites failing.  Will deal with that next.

Fix a memory corruption in posix.urandom

this let's us import random

In addition fix a valgrind uninitialized memory use warning
and close the opened file descriptor in posix.urandom

Has been failing with weird segfaults; hunting them down

Had to merge in some recent changes
- compileAndRunModule -> createAndRunModule
- new "allow-warning" directive syntax in tests

Also had to fix some bugs with codegen function types --
not sure how those snuck through

It doesn't create a new module at all -- it directly uses the existing one.

Fixing that let us clean up some of the module handling code.

Caught a couple benign places and one potentially-real issue.

Also fix a bug where we were rewriting all member descriptors
as OBJECT types (ie just load the offset), which is what was making
hashlib crash (the first thing that uses non-OBJECT member types).

(as long as you get a pointer to it in the right way)

1-arg version of exception constructors
str*bool -- who would have thought

- was missing comparison methods on 'long', and we were happily using the default comparison rules
- isinstance for oldstyle classes
- int * str (who does it that direction??)

Performance is abyssmal: 2s for us vs 30ms for CPython

In theory it's simple: we just run cheaper type analysis on lower tiers.
In practice it's more complicated, since the different tiers have to
cooperate on the types that they send back and forth.

I fixed up some of the code that didn't expect to receive a type worse
than what it knows to be true.  Ran into an issue where we have to
treat potentially-undefined symbols specially, since we can't do a class
check on them because they probably point to garbage.

Stopped there for now, since this section of the code is horrible and we
need to rewrite the tiering framework anyway.

- Use the right unpacking protocol (ie don't check __len__, just try to iterate)
- Handle unpacking exceptions appropriately
- Expand the targets of assigns correctly (think: f().x = 1)
-- this was not just for tuples but came up here first; this also was broken:
[0 for i in xrange(5)][0] = 1
(silly but legal)

fixed exception bases and added a few exception classes