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/application_ref.ts

@@ -14,7 +14,9 @@ import {ConcreteType, IS_DART, Type, isBlank, isPresent, isPromise} from '../src
 import {APP_INITIALIZER, PLATFORM_INITIALIZER} from './application_tokens';
 import {ChangeDetectorRef} from './change_detection/change_detector_ref';
 import {Console} from './console';
-import {Inject, Injectable, Injector, Optional, OptionalMetadata, SkipSelf, SkipSelfMetadata, forwardRef} from './di';
+import {Inject, Injectable, Injector, OpaqueToken, Optional, OptionalMetadata, ReflectiveInjector, SkipSelf, SkipSelfMetadata, forwardRef} from './di';
+import {AppModuleFactory, AppModuleRef} from './linker/app_module_factory';
+import {Compiler, CompilerFactory, CompilerOptions} from './linker/compiler';
 import {ComponentFactory, ComponentRef} from './linker/component_factory';
 import {ComponentFactoryResolver} from './linker/component_factory_resolver';
 import {ComponentResolver} from './linker/component_resolver';
@@ -111,6 +113,22 @@ export function createPlatform(injector: Injector): PlatformRef {
   return _platform;
 }
 
+/**
+ * Creates a fatory for a platform
+ *
+ * @experimental APIs related to application bootstrap are currently under review.
+ */
+export function createPlatformFactory(name: string, providers: any[]): () => PlatformRef {
+  const marker = new OpaqueToken(`Platform: ${name}`);
+  return () => {
+    if (!getPlatform()) {
+      createPlatform(
+          ReflectiveInjector.resolveAndCreate(providers.concat({provide: marker, useValue: true})));
+    }
+    return assertPlatform(marker);
+  };
+}
+
 /**
  * Checks that there currently is a platform
  * which contains the given token as a provider.
@@ -149,6 +167,70 @@ export function getPlatform(): PlatformRef {
   return isPresent(_platform) && !_platform.disposed ? _platform : null;
 }
 
+/**
+ * Creates an instance of an `@AppModule` for the given platform
+ * for offline compilation.
+ *
+ * ## Simple Example
+ *
+ * ```typescript
+ * my_module.ts:
+ *
+ * @AppModule({
+ *   modules: [BrowserModule]
+ * })
+ * class MyModule {}
+ *
+ * main.ts:
+ * import {MyModuleNgFactory} from './my_module.ngfactory';
+ * import {bootstrapModuleFactory} from '@angular/core';
+ * import {browserPlatform} from '@angular/platform-browser';
+ *
+ * let moduleRef = bootstrapModuleFactory(MyModuleNgFactory, browserPlatform());
+ * ```
+ *
+ * @experimental APIs related to application bootstrap are currently under review.
+ */
+export function bootstrapModuleFactory<M>(
+    moduleFactory: AppModuleFactory<M>, platform: PlatformRef): AppModuleRef<M> {
+  // Note: We need to create the NgZone _before_ we instantiate the module,
+  // as instantiating the module creates some providers eagerly.
+  // So we create a mini parent injector that just contains the new NgZone and
+  // pass that as parent to the AppModuleFactory.
+  const ngZone = new NgZone({enableLongStackTrace: isDevMode()});
+  const ngZoneInjector =
+      ReflectiveInjector.resolveAndCreate([{provide: NgZone, useValue: ngZone}], platform.injector);
+  return ngZone.run(() => moduleFactory.create(ngZoneInjector));
+}
+
+/**
+ * Creates an instance of an `@AppModule` for a given platform using the given runtime compiler.
+ *
+ * ## Simple Example
+ *
+ * ```typescript
+ * @AppModule({
+ *   modules: [BrowserModule]
+ * })
+ * class MyModule {}
+ *
+ * let moduleRef = bootstrapModule(MyModule, browserPlatform());
+ * ```
+ * @stable
+ */
+export function bootstrapModule<M>(
+    moduleType: ConcreteType<M>, platform: PlatformRef,
+    compilerOptions: CompilerOptions = {}): Promise<AppModuleRef<M>> {
+  const compilerFactory: CompilerFactory = platform.injector.get(CompilerFactory);
+  const compiler = compilerFactory.createCompiler(compilerOptions);
+  return compiler.compileAppModuleAsync(moduleType)
+      .then((moduleFactory) => bootstrapModuleFactory(moduleFactory, platform))
+      .then((moduleRef) => {
+        const appRef: ApplicationRef = moduleRef.injector.get(ApplicationRef);
+        return appRef.waitForAsyncInitializers().then(() => moduleRef);
+      });
+}
+
 /**
  * Shortcut for ApplicationRef.bootstrap.
  * Requires a platform to be created first.