refactor(core): clean up platform bootstrap and initTestEnvironment

- Introduces `CompilerFactory` which can be part of a `PlatformRef`.
- Introduces `WorkerAppModule`, `WorkerUiModule`, `ServerModule`
- Introduces `serverDynamicPlatform` for applications using runtime compilation
  on the server.
- Changes browser bootstrap for runtime and offline compilation (see below for an example).
  * introduces `bootstrapModule` and `bootstrapModuleFactory` in `@angular/core`
  * introduces new `browserDynamicPlatform` in `@angular/platform-browser-dynamic
- Changes `initTestEnvironment` (which used to be `setBaseTestProviders`) to not take a compiler factory any more (see below for an example).

BREAKING CHANGE:

## Migration from `setBaseTestProviders` to `initTestEnvironment`:

- For the browser platform:
  BEFORE:
  ```
  import {setBaseTestProviders} from ‘@angular/core/testing’;
  import {TEST_BROWSER_DYNAMIC_PLATFORM_PROVIDERS,
      TEST_BROWSER_DYNAMIC_APPLICATION_PROVIDERS} from ‘@angular/platform-browser-dynamic/testing’;

  setBaseTestProviders(TEST_BROWSER_DYNAMIC_PLATFORM_PROVIDERS,
      TEST_BROWSER_DYNAMIC_APPLICATION_PROVIDERS);
  ```

  AFTER:
  ```
  import {initTestEnvironment} from ‘@angular/core/testing’;
  import {browserDynamicTestPlatform,
      BrowserDynamicTestModule} from ‘@angular/platform-browser-dynamic/testing’;

  initTestEnvironment(
      BrowserDynamicTestModule,
      browserDynamicTestPlatform());

  ```
- For the server platform:
  BEFORE:
  ```
  import {setBaseTestProviders} from ‘@angular/core/testing’;
  import {TEST_SERVER_PLATFORM_PROVIDERS,
      TEST_SERVER_APPLICATION_PROVIDERS} from ‘@angular/platform-server/testing/server’;

  setBaseTestProviders(TEST_SERVER_PLATFORM_PROVIDERS,
      TEST_SERVER_APPLICATION_PROVIDERS);
  ```

  AFTER:
  ```
  import {initTestEnvironment} from ‘@angular/core/testing’;
  import {serverTestPlatform,
      ServerTestModule} from ‘@angular/platform-browser-dynamic/testing’;

  initTestEnvironment(
      ServerTestModule,
      serverTestPlatform());

  ```

## Bootstrap changes
```
@AppModule({
  modules: [BrowserModule],
  precompile: [MainComponent],
  providers: […], // additional providers
  directives: […], // additional platform directives
  pipes: […] // additional platform pipes
})
class MyModule {
  constructor(appRef: ApplicationRef) {
    appRef.bootstrap(MainComponent);
  }
}

// offline compile
import {browserPlatform} from ‘@angular/platform-browser’;
import {bootstrapModuleFactory} from ‘@angular/core’;

bootstrapModuleFactory(MyModuleNgFactory, browserPlatform());

// runtime compile long form
import {browserDynamicPlatform} from ‘@angular/platform-browser-dynamic’;
import {bootstrapModule} from ‘@angular/core’;

bootstrapModule(MyModule, browserDynamicPlatform());
```

Closes #9922
Part of #9726

modules/@angular/core/src/linker/compiler.ts

@@ -9,6 +9,7 @@
 import {Injector} from '../di';
 import {BaseException} from '../facade/exceptions';
 import {ConcreteType, Type, stringify} from '../facade/lang';
+import {ViewEncapsulation} from '../metadata';
 import {AppModuleMetadata} from '../metadata/app_module';
 
 import {AppModuleFactory} from './app_module_factory';
@@ -86,3 +87,64 @@ export class Compiler {
    */
   clearCacheFor(type: Type) {}
 }
+
+/**
+ * Options for creating a compiler
+ *
+ * @experimental
+ */
+export type CompilerOptions = {
+  useDebug?: boolean,
+  useJit?: boolean,
+  defaultEncapsulation?: ViewEncapsulation,
+  providers?: any[],
+  deprecatedAppProviders?: any[]
+}
+
+/**
+ * A factory for creating a Compiler
+ *
+ * @experimental
+ */
+export abstract class CompilerFactory {
+  static mergeOptions(defaultOptions: CompilerOptions = {}, newOptions: CompilerOptions = {}):
+      CompilerOptions {
+    return {
+      useDebug: _firstDefined(newOptions.useDebug, defaultOptions.useDebug),
+      useJit: _firstDefined(newOptions.useJit, defaultOptions.useJit),
+      defaultEncapsulation:
+          _firstDefined(newOptions.defaultEncapsulation, defaultOptions.defaultEncapsulation),
+      providers: _mergeArrays(defaultOptions.providers, newOptions.providers),
+      deprecatedAppProviders:
+          _mergeArrays(defaultOptions.deprecatedAppProviders, newOptions.deprecatedAppProviders)
+    };
+  }
+
+  withDefaults(options: CompilerOptions = {}): CompilerFactory {
+    return new _DefaultApplyingCompilerFactory(this, options);
+  }
+  abstract createCompiler(options?: CompilerOptions): Compiler;
+}
+
+class _DefaultApplyingCompilerFactory extends CompilerFactory {
+  constructor(private _delegate: CompilerFactory, private _options: CompilerOptions) { super(); }
+
+  createCompiler(options: CompilerOptions = {}): Compiler {
+    return this._delegate.createCompiler(CompilerFactory.mergeOptions(this._options, options));
+  }
+}
+
+function _firstDefined<T>(...args: T[]): T {
+  for (var i = 0; i < args.length; i++) {
+    if (args[i] !== undefined) {
+      return args[i];
+    }
+  }
+  return undefined;
+}
+
+function _mergeArrays(...parts: any[][]): any[] {
+  let result: any[] = [];
+  parts.forEach((part) => result.push(...part));
+  return result;
+}