Add a changelog entry for the function-type syntax.

CHANGELOG.md

 ## 1.24.0
 
 ### Language
 * During a dynamic type check, `void` is not required to be `null` anymore.
   In practice, this makes overriding `void` functions with non-`void` functions
   safer.
 * During static analysis, a function or setter declared using `=>` with return
   type `void` now allows the returned expression to have any type. For example,
   assuming the declaration `int x;`, it is now type correct to have
   `void f() => ++x;`.
+* A new function-type syntax has been added to the language.
+  Intuitively, the type of a function can be constructed by textually replacing
+  the function's name with `Function` in its declaration. For instance, the
+  type of `void foo() {}` would be `void Function()`. The new syntax may be used
+  wherever a type can be written. It is thus now possible to declare fields
+  containing functions without needing to write typedefs: `void Function() x;`.
+  The new function type has one restriction: it may not contain the old-style
+  function-type syntax for its parameters. The following is thus
+  illegal: `void Function(int f())`.
+  `typedefs` have been updated to support this new syntax.
+  Examples:
+  ```
+  typedef F = void Function();  // F is the name for a `void` callback.
+  int Function(int) f;  // A field `f` that contains an int->int function.
+
+  class A<T> {
+    // The parameter `callback` is a function that takes a `T` and returns
+    // `void`.
+    void forEach(void Function(T) callback);
+  }
+
+  // The new function type supports generic arguments.
+  typedef Invoker = T Function<T>(T Function() callback);
+  ```
 
 #### Strong Mode
 
 * Removed ad hoc Future.then inference in favor of using FutureOr.  Prior to
 adding FutureOr to the language, the analyzer implented an ad hoc type inference
 for Future.then (and overrides) treating it as if the onValue callback was typed
 to return FutureOr for the purposes of inference.  This ad hoc inference has
 been removed now that FutureOr has been added.
 
 Packages that implement `Future` must either type the `onValue` parameter to
 `.then` as returning `FutureOr<T>`, or else must leave the type of the parameter
 entirely to allow inference to fill in the type.
 
 * The following is also a change in strong mode: During static analysis, a
   function or setter declared using `=>` with return type `void` now allows the
   returned expression to have any type.
+* The new function-type syntax is also supported by strong mode.
 
 ### Core library changes
 
 * `dart:io`
   * Added `Platform.localeName`, needed for accessing the locale on platforms
     that don't store it in an environment variable.
   * Added `ProcessInfo.currentRss` and `ProcessInfo.maxRss` for inspecting
     the Dart VM process current and peak resident set size.
   * Added 'RawSynchronousSocket', a basic synchronous socket implementation.
 * `dart:convert`
@@ skipping 1880 matching lines @@
     they will keep the Dart process alive until they time out. This fixes the
     handling of persistent connections. Previously, the client would shut down
     immediately after a request.
 
   * **Breaking change:** `HttpServer` no longer compresses all traffic by
     default. The new `autoCompress` property can be set to `true` to re-enable
     compression.
 
 * `dart:isolate`: `Isolate.spawnUri` added the optional `packageRoot` argument,
   which controls how it resolves `package:` URIs.