Specs: strip @nonnull annotations since they're too verbose

sky/specs/script.md

 Sky Script Language
 ===================
 
 The Sky script language is Dart.
 
 The way that Sky integrates the module system with its script language
 is described in [modules.md](modules.md).
 
-When an method defined as ``external`` receives an argument, it must
-type-check it, and, if the argument's value is the wrong type, then it
-must throw an ArgumentError as follows:
+All the APIs defined in this documentation, unless explicitly called
+out as being in a framework, are in the `dart:sky` built-in module.
+
+When a method in `dart:sky` defined as ``external`` receives an
+argument, it must type-check it, and, if the argument's value is the
+wrong type, then it must throw an ArgumentError as follows:
 
    throw new ArgumentError(value, name: name);
 
-...where "name" is the name of the argument.
-
-Further, if the type of the argument is annotated with ``@nonnull``,
-then the method must additionally throw if the value is of type Null,
-as follows:
-
-   throw new ArgumentError.notNull(name);
-
-The ``@nonnull`` annotation is defined as follows:
-
-```dart
-const nonnull = const Object();
-```
-
-The ``@nonnull`` annotation does nothing in code not marked
-``external``, but it has been included anyway for documentation
-purposes. It indicates places where providing a null is a contract
-violation and that results are therefore likely to be poor.
+...where "name" is the name of the argument. Type checking here
+includes rejecting nulls unless otherwise indicated or unless null is
+argument's default value.
 
 The following definitions are exposed in ``dart:sky``:
 
 ```dart
 abstract class AutomaticMetadata {
   const AutomaticMetadata();
   void init(DeclarationMirror target, Module module);
 
   static void runLibrary(LibraryMirror library, Module module) {
     library.declarations.values.toList()..sort((DeclarationMirror a, DeclarationMirror b) {
@@ skipping 55 matching lines @@
   to a superclass' constructor, wherein the subclass' constructor has
   the same arguments as the superclass' constructor and does nothing
   but invoke that superclass' constructor with the same arguments. The
   syntax for defining this is, within the class body for a class
   called ClassName:
 
 ```dart
      ClassName = SuperclassName;
      ClassName.namedConstructor = SuperclassName.otherNamedConstructor;
 ```