Required to reraise correct exceptions in except block, regardless if more
try blocks with active exceptions happen in the same except block.

P.S. This "automagic reraise" appears to be quite wasteful feature of Python
- we need to save pending exception just in case it *might* be reraised.
Instead, programmer could explcitly capture exception to a variable using
"except ... as var", and reraise that. So, consider disabling argless raise
support as an optimization.

E.g. to handle currently_in_except_block restoring properly.

Adds readline_init() to clear readline history on soft reset.  Addresses
issue #387.

The compiler allocates 7 entries on the stack for a with statement
(following CPython, but probably can be reduced).  This is enough for
the method load and call in SETUP_WITH.

With statement implementation

Addresses issue #388.

Implement "yield from"

Partly (very partly!) addresses issue #386.  Most importantly, at the
REPL command line, each invocation does not now lead to increased memory
usage (unless you define a function/lambda).

This reduntant triple is one of the ugliest parts of Python, which they
chickened out to fix in Python3. We really should consider passing just
as single exception instance (without breaking Python-level APIs of course),
but until we do, let's follow CPython layout.

Will be reused in WITH bytecodes.

objgenerator: close(): Throw instance of GeneratorExit (not type).

show_bc now decodes the prelude correctly.  Moved WRITE_FILE stuff from
runtime.c to emitglue.c.

Addresses issue #385.

Handling of GeneratorExit is really peculiar - it subverts normal exception
propagation rules.

To comply with Python semantics and allow use of mp_obj_is_subclass_fast()
for exception matching.

Only exceptions that are actually used are left prefedined.  Hierarchy
is still there, and removed exceptions are just commented out.

Rationale: setting up the stack (state for locals and exceptions) is
really part of the "code", it's the prelude of the function.  For
example, native code adjusts the stack pointer on entry to the function.
Native code doesn't need to know n_state for any other reason.  So
putting the state size in the bytecode prelude is sensible.

It reduced ROM usage on STM by about 30 bytes :)  And makes it easier to
pass information about the bytecode between functions.