ES6 module syntax update

## Important Notice

This is a non-backward compatible change in esprima:harmony branch since it removes some syntax from previous drafts that were specs recently and introduces the changes to align with the final draft.

### Issues

* https://code.google.com/p/esprima/issues/detail?id=597

## Changes

* revision of ES6 import final grammar based on specs
* revision of ES6 export final grammar based on specs
* tests for import/export syntax in a separate test file for conviniece
* introduces `Syntax.ImportNamespaceSpecifier` for `import * as foo from "foo"`
* introduces `Syntax.ImportDefaultSpecifier` for `import foo from "foo";`
* removes `kind=default` and `kind=named` from `ImportDeclaration` in favor of
  `Syntax.ImportDefaultSpecifier` form
* removes `module {}` syntax
* clean up old tests from `harmonytest.js`

## Export Syntax

```javascript
// default exports
export default 42;
export default {};
export default [];
export default foo;
export default function () {}
export default class {}
export default function foo () {}
export default class foo {}
 
// variables exports
export var foo = 1;
export var foo = function () {};
export var bar; // lazy initialization
export let foo = 2;
export let bar; // lazy initialization
export const foo = 3;
export function foo () {}
export class foo {}
 
// named exports
export {foo};
export {foo, bar};
export {foo as bar};
export {foo as default};
export {foo as default, bar};
 
// exports from
export * from "foo";
export {foo} from "foo";
export {foo, bar} from "foo";
export {foo as bar} from "foo";
export {foo as default} from "foo";
export {foo as default, bar} from "foo";
export {default} from "foo";
export {default as foo} from "foo";
```

## Import Syntax

```javascript
// default imports
import foo from "foo";
import {default as foo} from "foo";
 
// named imports
import {bar} from "foo";
import {bar, baz} from "foo";
import {bar as baz} from "foo";
import {bar as baz, xyz} from "foo";
 
// glob imports
import * as foo from "foo";
 
// mixing imports
import foo, {baz as xyz} from "foo";
import * as bar, {baz as xyz} from "foo";

// just import
import "foo";
```

## Invalid Syntax

```javascript
export const bar;
// const variables must have an initializer
 
export foo;
// Unexpected token identifier, invalid named export syntax
 
export function () {}
// Unexpected token (, use a function declaration instead
 
export function default () {}
// Unexpected token default
 
import foo;
// Missing from after import
 
import { foo, bar };
// Missing from after import
 
import foo from bar;
// Invalid module specifier
 
import default from "foo";
// Unexpected token default
 
export default from "foo";
// Unexpected token from
 
export {default};
// Missing from after export
 
export *;
// Missing from after export
 
import {default as foo};
// Missing from after import
 
import * from "foo";
// Missing as after import *'
 
export default = 42;
// Unexpected token =
 
import {bar as default} from "foo";
// Unexpected token default

import foo, * as bar, {baz as xyz} from "foo";
// Unexpected token *

import {bar}, foo from "foo";
// Unexpected token ,

import {bar}, * as foo from "foo";
// Unexpected token ,

import foo, {bar}, foo from "foo";
// Unexpected token ,

import {bar}, {foo} from "foo";
// Unexpected token ,
```

## TODO

* [x] sign off from modules champions (@wycats, @dherman)
* [ ] follow up with `es6-module-transpiler`
* [ ] follow up with `recast` builders
* [ ] follow up with `recast` ast-types

/cc @ericf @domenic @guybedford @benjamn @eventualbuddha @jeffmo
Unless I'm mistaken, we need a way of specifying whether the `ExportDeclaration` is `default` or not.

As long as we're making breaking changes, I would even say it deserves to be the first parameter:
```js
createExportDeclaration: function (isDefault, declaration, specifiers, source) {
    return {
        type: Syntax.ExportDeclaration,
        "default": !!isDefault,
        declaration: declaration,
        specifiers: specifiers,
        source: source
    };
},
```
There's already some precedent for this in https://github.com/benjamn/ast-types/blob/801953a460e456e0ad9a2cc4ab7d5314888b8af8/def/es6.js#L171-L172, for what it's worth.