Speed up Travis by running Webpack in fewer tests (#381)

* Reorganize Travis configuration

* Add a `JOB` env var descriptor to all matrix entries. Not used anywhere but is
  useful when viewing the whole build on Travis's web interface.
* Reorganize where builds are located, moving slow builds first and fast ones
  last.
* Change checking the CLI builds from `cargo build` to `cargo check`
* Use YAML references to reduce some duplication

* Print some more timing statistics for each test

* Extract `Project` helper in tests to a module

This'll help make it a bit more extensible over time. At the same time the
methods are also slightly reorganized to read more clearly from top to bottom.

* Migrate all tests away from Webpack

Wepback can take a significant amount of time to execute and when it's
multiplied by hundreds of tests that adds up really quickly! After investigating
Node's `--experimental-modules` option it looks like it's suitable for our use
so this switches all tests to using JS files (moving away from TypeScript as
well) with `--experimental-modules` with Node.

Tests will be selectively re-enabled with webpack and node.js specific output
(that doesn't require `--experimental-modules`), coming in later commits.

* Restore the node test for node.js output

Ensures it's workable as-is

* Only generate typescript with webpack

* Only read wasm files for webpack

* Skip package.json/node_modules for now

* Only generate webpack config if needed

* Start a dedicated test module for typescript

Will hopefully verify the generated Typescript compiles OK.

* Remove unneeded `node` method

* Fixup some rebase conflicts

* Don't run asmjs example on travis

* Fixup generator tests

* Attempt to fix windows

* Comment windows fix

* More test fixes

* More exclusions

* More test fixes

* Relax eslint regex

Catch mjs modules as well

* Fix eslint

* Speed up travis on examples slightly

tests/all/typescript.rs

@@ -0,0 +1,79 @@
+use super::project;
+
+#[test]
+fn works() {
+    project()
+        .webpack(true)
+        .file(
+            "src/lib.rs",
+            r#"
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+
+                extern crate wasm_bindgen;
+
+                use wasm_bindgen::prelude::*;
+
+                #[wasm_bindgen]
+                pub fn foo() {}
+
+                #[wasm_bindgen]
+                pub fn bar(a: &str, b: u32) -> String {
+                    format!("{} {}", a, b)
+                }
+
+                #[wasm_bindgen]
+                pub fn thunk(a: &JsValue) {
+                    drop(a);
+                }
+
+                #[wasm_bindgen]
+                pub struct A {
+                }
+
+                #[wasm_bindgen]
+                impl A {
+                    #[wasm_bindgen(constructor)]
+                    pub fn new() -> A {
+                        A {}
+                    }
+
+                    pub fn new2() -> A {
+                        A {}
+                    }
+
+                    pub fn foo(&self) {}
+
+                    pub fn bar(&self, _a: u32) {}
+
+                    pub fn baz(&self, _d: &A) {}
+                }
+            "#,
+        )
+        .file(
+            "test.ts",
+            r#"
+                import * as assert from 'assert';
+                import { foo, bar, A, thunk } from './out';
+                import { memory } from './out_bg';
+
+                export function test() {
+                    foo();
+                    assert.strictEqual(bar('a', 3), 'a 3');
+
+                    const x = new A();
+                    x.foo();
+                    x.free();
+
+                    const y = A.new2();
+                    y.foo();
+                    y.bar(2);
+                    y.baz(y);
+                    y.free();
+
+                    thunk(memory);
+                };
+            "#,
+        )
+        .test();
+}
+