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.