fix(expression extractor): Do not use implicit DI
chore: remove empty file
fix(directive): Support multiple directives with same selector.
perf(View): Improve View instantiation speed and memory consumption.

View contains many injectors which are expensive in both speed and memory. The
New DirectiveInjector assumes that there are no more than 10 directives
per element and can be a lot more efficient than a array/hash lookup and
those it can be faster as well as smaller. This change makes View
instantiation speed 4x faster in Dartium VM.

BREAKING CHANGE:

- Injector no longer supports visibility
- The Directive:module instead of returning Module now takes
  DirectiveModule (which supports visibility)
- Application Injector and DirectiveInjector now have separate trees.
  (The root if DirectiveInjector is ApplicationInjector)
refactor: Drop the Controller directive

closes #919
closes #917

1) The @Controller has been removed

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

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

The root context type needs to be annotated with @Injectable():

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

2) You can not inject a scope in a component or in the root 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 a reference to
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
       }
     }
feat: Removing implicit map dereference in expressions

Closes #915

1) Now "a.b" return a.b and "a['b']" return a['b']

Before this change a.b would have match either a.b or a['b']. The reason
is that the context was a Map (before #914) and we don't want to write
ctrl['foo'] but ctrl.foo. It was also not possible to access Map
properties, ie map.length would have returned map['length'].

2) Accessing probes

The probes are no more accessible directly in the rootScope context but
in a $probes map on the rootScope context.

Before:

    <p probe="prb"></p>

    var probe = rootScope.context['prb'];

After:

    <p probe="prb"></p>

    var probe = rootScope.context.$probes['prb'];