Generator use try stack runtime

By using a stack to keep track of try/catch/finally we can move a lot of logic from the generated code to a runtime function. This allows the codegen to become significantly smaller.

```js
function* f() {
  try {
    yield 1;
  } catch (ex) {
    yield ex;
  }
}
```

Before:
```js
function f() {
  var ex;
  var $that = this,
      $arguments = arguments,
      innerFunction = function($ctx) {
        while (true) switch ($ctx.state) {
          case 0:
            $ctx.state = 2;
            return 1;
          case 2:
            if ($ctx.action == 1) {
              $ctx.action = 0;
              throw $ctx.sent;
            }
            $ctx.state = 4;
            break;
          case 9:
            ex = $ctx.storedException;
            $ctx.state = 5;
            break;
          case 5:
            $ctx.state = 6;
            return ex;
          case 6:
            if ($ctx.action == 1) {
              $ctx.action = 0;
              throw $ctx.sent;
            }
            $ctx.state = 4;
            break;
          case 4:
            $ctx.state = -2;
          case -2:
            return $ctx;
          case -3:
            throw $ctx.storedException;
          default:
            throw "traceur compiler bug: invalid state in state machine: " + $ctx.state;
        }
      },
      moveNext = function($ctx) {
        while (true) {
          try {
            return innerFunction($ctx);
          } catch (ex) {
            $ctx.storedException = ex;
            switch ($ctx.state) {
              case 2:
                $ctx.state = 9;
                break;
              default:
                $ctx.GState = 3;
                $ctx.state = -2;
                throw $ctx.storedException;
            }
          }
        }
      };
  return $traceurRuntime.generatorWrap(moveNext);
}
```

After:
```js
function f() {
  var ex;
  var $that = this,
      $arguments = arguments;
  return $traceurRuntime.generatorWrap(function($ctx) {
    while (true) switch ($ctx.state) {
      case 0:
        $ctx.pushTry(9, null);
        $ctx.state = 12;
        break;
      case 12:
        $ctx.state = 2;
        return 1;
      case 2:
        if ($ctx.action == 1) {
          $ctx.action = 0;
          throw $ctx.sent;
        }
        $ctx.state = 4;
        break;
      case 4:
        $ctx.popTry();
        $ctx.state = 14;
        break;
      case 9:
        $ctx.popTry();
        ex = $ctx.storedException;
        $ctx.state = 5;
        break;
      case 5:
        $ctx.state = 6;
        return ex;
      case 6:
        if ($ctx.action == 1) {
          $ctx.action = 0;
          throw $ctx.sent;
        }
        $ctx.state = 14;
        break;
      case 14:
        $ctx.state = -2;
      case -2:
        return $ctx;
      case -3:
        throw $ctx.storedException;
      default:
        throw "traceur compiler bug: invalid state in state machine: " + $ctx.state;
    }
  });
}
```

Review URL: https://github.com/google/traceur-compiler/pull/699

Closes #699.
Separate std and non-std Loader functions.

Std Loader in Loader; extensions in TraceurLoader.
System now instance of TraceurLoader.

Review URL: https://github.com/google/traceur-compiler/pull/704

Closes #704.
Rename traceur.modules.Loader to traceur.runtime.Loader.

One missed from last commit. Fixes #708

TBR=@arv

Review URL: https://github.com/google/traceur-compiler/pull/711

Closes #711, closes #708.
Use System.import in repl.html

Fixes #708

Review URL: https://github.com/google/traceur-compiler/pull/712

Closes #712, closes #708.
Refactor generator runtime generatorWrap to reduce code duplication

Review URL: https://github.com/google/traceur-compiler/pull/717

Closes #717.
Loader prototype module

Loader.prototype.module no longer takes a name param and we do not register the module in the module registry.

With the old code we got the completion value out of `module` but not any more. The value out was a Module which cannot be toString'ed so I remove the result from the repl.

Also, while I was fixing the repl I fixed a few repl bugs that have been piling up.

Fixes #710
Fixes #713
Fixes #634

Review URL: https://github.com/google/traceur-compiler/pull/716

Closes #716, closes #710, closes #713, closes #634.
Clean up generator code further

- Pass `this` into runtime function so that the function is called with the right context. Removes the need for `$that = this`
- Use an alpha renamer for `arguments` and detect if `arguments` was present.
- Move shared code to super class.
- Remove unused imports.

Review URL: https://api.github.com/repos/google/traceur-compiler/issues/719

Closes #719.
Generator collapse end state

We used to always output

```js
case 4:
  $ctx.state = END_STATE;
case END_STATE:
  ...
```

Now we skip the state before the END_STATE.

Review URL: https://api.github.com/repos/google/traceur-compiler/issues/720

Closes #720.
Runtime type assertions

Added a new feature to insert runtime type assertions for type annotations.  The type assertions are added as <code>assert.type(value, Type);</code>.  In order to simplify the insertion of the assertion into variable declarations and return statements it is expected that <code>assert.type</code> return the value passed to it.

Once we support more types of type annotations we will need to come up with a way of representing the annotations in a way that will allow us to call the <code>assert.type</code> function with the additional information represented by the type annotation.

The type assertions are controlled by two new flags:
* <code>--type-assertions</code> (boolean): Turns on assertion generation
* <code>--type-assertions-module</code> (string): Specifies an import path to a type assertion library.  If this module path is specified then an import statement is added for the assertion library.  Otherwise it is assumed that an assertion library which implements the type check is exposed globally.

Example:
```javascript
function isStringEmpty(value:String):Boolean {
  return value ? value.length > 0 : false;
}
```
Would generate:
```javascript
function isStringEmpty(value) {
  assert.type(value, String);
  return assert.type(value ? value.length > 0: false, Boolean);
}
```

Review URL: https://api.github.com/repos/google/traceur-compiler/issues/721

Closes #721.
New module compilation option: inline

This PR adds a new module transformer `inline` that produces very trivial module output when compiled as a single file. A module will be compiled to something like this:

```
var $__module__static_47_scripts_47_modules_47_TargetView_46_js__ = (function() {
  "use strict";
  var __moduleName = "static/scripts/modules/TargetView.js";
  // ...
}).call(this);
```

References to the module simply become: `__module__static_47_scripts_47_modules_47_TargetView_46_js__`

As I see it is has the following advantages when compiled in single-file mode:
- friendlier for compression tools like UglifyJS and Google Closure compiler, which can rename the lengthy module names to single variable names
- does not leak information about file structure when minified (`__moduleName` is often unused and is also stripped)
- no need for a module store in the runtime (although obviously this patch does not change the fact that it's there and compressors are not smart enough to remove it when minifying)

I'd love to see the single-file output of Traceur be a little more friendlier for web-use and JS minification tools. I hope this is one step in that direction.

The default in single-file compilation mode was not changed although I'd imagine that might be much more helpful for users unaware of this configuration option.

When I apply this change and remove the module store and url module from the runtime I can get a small sample project down from ~21KB uncompressed to ~16KB uncompressed.

Please consider this PR and let me know if there's anything I can do to improve the implementation or the test coverage.

Review URL: https://api.github.com/repos/google/traceur-compiler/issues/702

Closes #702.