chore: add flowdock to travis
fix(compiler): OneWayOneTime bindings now wait for the model to stablize

BREAKING CHANGE

Previously, OneWayOneTime bindings would remove their watch after the
first value assignment.  For models that take more than one digest loop
to stablize, this meant the OneWayOneTime bindings took a un-stablized
value.

With this change, these bindings will continue to accept value
assignments until their stablized value is non-null. The assignment may
occur multiple times.

We expect that most uses of OneWayOneTime will be 'ok' with
being called a few times as the model stablizes.

However, applications which depend on OneWayOneTime bindings being
called exactly once will break.  The suggested upgrade path is to
move the senstive code into a domWrite callback. e.g. the old code:

    @Decorator(
        map: const { 'one-time': '=>!value' })
    class OneTime {
      set value(v) => onlyCalledOnce(v);
    }

becomes

    @Decorator(
        map: const { 'one-time': '=>!value' })
    class OneTime {
      var _value;
      set value(v) {
        if (_value == null) {
	  scope.rootScope.domWrite(() => onlyCalledOnce(_value));
	}
      	_value = v;
      }
    }

Closes #1013
refactor: Drop the Controller directive

closes #919
closes #917

1) The @Controller annotation is no more

It is possible to define the context of the root scope with:

    applicationFactory()
        ..rootContextType(RootContext)
        ..run();

The RootContext needs to be annotated with @Injectable():

    @Injectable()
    class RootContext {
      // ...
    }

2) You can not inject a scope in a component or in theroot context any
more

As the Scope context is set to the Component instance, the scope could
not be injected any more. Components should implements the "ScopeAware"
interface and declare a "scope" setter in order to get hold of the
scope.

before:

     @Component(...)
     class MyComponent {
       Watch watch;
       Scope scope;

       MyComponent(Dependency myDep, Scope scope) {
          watch = scope.rootScope.watch("expression", (v, p) => ...);
       }
     }

after:

     @Component(...)
     class MyComponent implements ScopeAware {
       Watch watch;

       MyComponent(Dependency myDep) {
         // It is an error to add a Scope / RootScope argument to the
         // ctor and will result in a DI circular dependency error
		 // The scope is never accessible in the class constructor
       }

       void set scope(Scope scope) {
          // This setter gets called to initialize the scope
          watch = scope.rootScope.watch("expression", (v, p) => ...);
       }
     }

or

     @Component(...)
     class MyComponent implements ScopeAware {
       Scope scope;

       MyComponent(Dependency myDep) {
         // It is an error to add a Scope / RootScope argument to the
         // ctor and will result in a DI circular dependency error
		 // The scope is never accessible in the class constructor
       }
     }
tentative fix