js2coffee was not correctly indenting code such as:

    while (true) {
          {
                {
                        var a = 0;
                        var b = 1;
                }
          }
    }

In that case you'd get:

    loop
        a = 0
      b = 1

The reason is that the code that emits 'BlockStatement' was
unconditionally prepending the current indent to each of its children.
In the preceding case, the code would add an indent to the top-level
BlockStatement then an indent for each child "a = 0" and "b = 0", resulting
in then output:

    ["loop", "\n", "  ", "  ", "a", "=", "0", "\n", " ", "b", "=", "0", "\n"]

This code makes it so that the code that emits 'BlockStatement' only outputs
an indent if the child isn't of type 'BlockStatement', effectively flattening
the output.

The `scope` member in the transformer base was being set to
the previously pushed scope on `popStack`, instead of the
scope that was active that before the previously pushed scope
was pushed. This resulted in code like:

    var a = 0;
    var foo = function () {
      var b = function () {
        return 0;
      };
      var a = 1;
    };

Being compiled into:

    a = 0
    foo = ->
      b = ->
        `var a`
        0
      a = 1
      return

The preceding example would happen because the duplicate
VariableDeclaration for `a` would trigger js2coffee's variable shadowing
handling code, automatically placing the `var a` at the the
top of the current scope's body. The current scope was erroneously
left as the last pushed scope, hence `var a` would be placed at the
top of the "b" function.

The `estraverse` module iterates over a function's AST body
using fixed indices stored when the function is first entered.
If the body of a function is modified during those methods, it can cause
unexpected outcomes during traversal. One outcome is the complete
skipping of a sub-statement. This change fixes that.