Use traverse() for normalizing nodes

Most normalize() functions were just calling normalize() on their
children. traverse() does just that, does it in less code and is more
consistent about it. The old code didn't always call normalize()
correctly (on all child nodes, with the right arguments, etc), so this
also fixes bugs such as:

    id = setTimeout(cont(m));   // crashes the compiler

    alert(cont(foo.bar.baz));   // produces invalid code

    { x++ }; alert(cont());     // the "x++" disappears

(The third test case doesn't work yet -- normalize() is fixed, but
transform() also needs changing.)
Don't store async boolean in nodes

The place argument to transform() basically means "please put this
statement into this array", and the return value of transform() means
"successive statements should go into this array". When the node is
asynchronous, the two value differ (most likely, the argument is the
containing block and the return value is the body of a callback
function). So there's no need to remember that separately, comparing
the original block body and the transform() return value is enough.

This also fixes some cases where transform() wasn't called, its
return value was ignored, or async wasn't properly being set.
Fix synchronous try/catch blocks

This fixes the following test case:

    try { x++ } catch(e) { y++ }
    z++; alert(cont());
Fix nested block statements

The following test case now works:

    { x++ }; alert(cont());
Add tests for nested block and sync try statement