Update strong mode doc

doc/GENERIC_METHODS.md

 # Strong mode generic method prototype syntax
 
 This is a summary of the current (as of January 2016) comment-based generic
 method syntax supported by the analyzer strong mode and the Dart Dev Compiler.
 The comment-based syntax essentially uses the proposed actual generic method
 syntax, but wraps it in comments.  This allows developers to experiment with
 generic methods while still ensuring that their code runs on all platforms while
 generic methods are still being evaluated for inclusion into the language.
 
 ## Declaring generic method parameters
@@ skipping 55 matching lines @@
 Dart by writing a type followed by `/*=T*/`.  So for example, `dynamic /*=T*/`
 will be interpreted as `dynamic` by all non-strong mode tools, but will be
 interpreted as `T` by strong mode.  In places where it is valid to leave off a
 type, simply writing `/*=T*/` will be interpreted as `dynamic` by non-strong
 mode tools, but will be interpreted as `T` by strong mode.  For example:
 
 ```dart
 // foo is a generic method which takes a single generic method parameter S.
 // In strong mode, the parameter x will have type S, and the return type will
 // be S
-// In normal mode, the parameter x will have type dynamic, and the return 
+// In normal mode, the parameter x will have type dynamic, and the return
 // type will be dynamic.
 dynamic/*=S*/ foo/*<S>*/(dynamic/*=S*/ x) { return x; }
 ```
 
 This can be written more concisely by leaving off the `dynamic`.
 
 ```dart
 /*=S*/ foo/*<S>*/(/*=S*/ x) {return x;}
 ```
 
 You can also put a type to the left of the `/*=T/`. This type will be used
 for all non-strong mode tools. For example:
 
 ```dart
 // This method works with `int`, `double`, or `num`. The return type will
 // match the type of the parameters.
 num/*=T*/ pickAtRandom/*<T extends num>*/(num/*=T*/ x, num/*=T*/ y) { ... }
 ```
 
 
 Note that the generic parameter is in scope in the return type of the function,
 in the argument list of the function, and in the body of the function.  When
 declaring local variables and parameters, you can also use the `/*=T*/` syntax with `var`.
 
 ```dart
 // foo is a generic method that takes a single generic parameter S, and a value
 // x of type S
 void foo/*<S>*/(var /*=S*/ x) {
-  // In strong mode, y will also have type S 
+  // In strong mode, y will also have type S
   var /*=S*/ y = x;
 
   // In strong mode, z will also have type S
   dynamic /*=S*/ z = y;
 }
 ```
 
 Anywhere that a type literal is expected, you can also use the `/*=T*/` syntax to
 produce a type literal from the generic method parameter.
 
@@ skipping 12 matching lines @@
 You can use generic method parameters to instantiate generic classes using the
 same `/*=T*/` syntax.
 
 ```dart
 // foo is a generic method which returns a List<S> in strong mode,
 // but which returns List<dynamic> in normal mode.
 List<dynamic /*=S*/> foo/*<S>*/(/*=S*/ x) {
    // l0 is a list literal whose reified type will be List<S> in strong mode,
    // and List<dynamic> in normal mode.
    var l0 = <dynamic /*=S*/>[x];
-   
+
    // as above, but with a regular constructor.
    var l1 = new List<dynamic /*=S*/>();
    return l1;
 }
 ```
 
 In most cases, the entire type argument list to the generic class can be
 enclosed in parentheses, eliminating the need for explicitly writing `dynamic`.
 
 ```dart
 // This is another way of writing the same code as above
 List/*<S>*/ foo/*<S>*/(/*=S*/ x) {
    // The shorthand syntax is not yet supported for list and map literals
    var l0 = <dynamic /*=S*/>[x];
-   
+
    // but with regular constructors you can use it
    var l1 = new List/*<S>*/();
    return l1;
 }
 ```
 
 ## Instantiating generic methods
 
 Generic methods can be called without passing type arguments.  Strong mode will
 attempt to infer the type arguments automatically.  If it is unable to do so,
@@ skipping 27 matching lines @@
   C c = new C();
   // This line will produce a type error, because strong mode will infer
   // `int` as the generic argument to fill in for S
   String x = c.inferableFromArgument(3);
 
   // This line will produce a type error in strong mode, because `int` is
   // explicitly passed in as the argument to use for S
   String y = c.notInferable/*<int>*/(3);
 }
 ```