Add JSON protocol support for groups.

json_reporter.md

 JSON Reporter Protocol
 ======================
 
 The test runner supports a JSON reporter which provides a machine-readable
 representation of the test runner's progress. This reporter is intended for use
 by IDEs and other tools to present a custom view of the test runner's operation
 without needing to parse output intended for humans.
 
 ## Usage
 
@@ skipping 34 matching lines @@
 ## Reading this Document
 
 Each major type of JSON object used by the protocol is described by a class.
 Classes have names which are referred to in this document, but are not used as
 part of the protocol. Classes have typed attributes, which refer to the types
 and names of attributes in the JSON objects. If an attribute's type is another
 class, that refers to a nested object. The special type `List<...>` indicates a
 JSON list of the given type.
 
 Classes can "extend" one another, meaning that the subclass has all the
-properties of the superclass. Concrete subclasses can be distinguished by the
+attributes of the superclass. Concrete subclasses can be distinguished by the
 specific value of their `type` attribute. Classes may be abstract, indicating
 that only their subclasses will ever be used.
 
 ## Events
 
 ### Event
 
 ```
 abstract class Event {
   // The type of the event.
@@ skipping 22 matching lines @@
   String protocolVersion;
 
   // The version of the test runner being used.
   String runnerVersion;
 }
 ```
 
 A single start event is emitted before any other events. It indicates that the
 test runner has started running.
 
+### GroupEvent
+
+```
+class GroupEvent extends Event {
+  String type = "group";
+
+  /// Metadata about the group.
+  Group group;
+}
+```
+
+A group event is emitted before any `TestStartEvent`s for tests in a given
+group. This is the only event that contains the full metadata about a group;
+future events will refer to the group by its opaque ID.
+
+This includes the implicit group at the root of each suite, which has a `null`
+name. However, it does *not* include implicit groups for the virtual suites
+generated to represent loading test files.
+
+The group should be considered skipped if `group.metadata.skip` is `true`. When
+a group is skipped, a single `TestStartEvent` will be emitted for a test within
+that group that will also be skipped.
+
 ### TestStartEvent
 
 ```
 class TestStartEvent extends Event {
   String type = "testStart";
 
   // Metadata about the test that started.
   Test test;
 }
 ```
@@ skipping 94 matching lines @@
   String type = "done";
 
   // Whether all tests succeeded (or were skipped).
   bool success;
 }
 ```
 
 An event indicating the result of the entire test run. This will be the final
 event emitted by the reporter.
 
-## Test Information
+## Other Classes
 
 ### Test
 
 ```
 class Test {
   // An opaque ID for the test.
   int id;
 
   // The name of the test, including prefixes from any containing groups.
   String name;
 
-  // The test's metadata, including metadata from any containing groups and the
-  // test suite itself.
+  // The IDs of groups containing this test, in order from outermost to
+  // innermost.
+  List<int> groupIDs;
+
+  // The test's metadata, including metadata from any containing groups.
   Metadata metadata;
 }
 ```
 
 A single test case. The test's ID is unique in the context of this test run.
 It's used elsewhere in the protocol to refer to this test without including its
 full representation.
 
+Most tests will have at least one group ID, representing the implicit root
+group. However, some may not; these should be treated as having no group
+metadata.
+
+### Group
+
+```
+class Group {
+  // An opaque ID for the group.
+  int id;
+
+  // The name of the group, including prefixes from any containing groups.
+  String? name;
+
+  // The ID of the group's parent group, unless it's the root group.
+  int? parentID;
+
+  // The group's metadata, including metadata from any containing groups.
+  Metadata metadata;
+}
+```
+
+A group containing test cases. The group's ID is unique in the context of this
+test run. It's used elsewhere in the protocol to refer to this test without
+including its full representation.
+
+The implicit group at the root of each test suite has `null` `name` and
+`parentID` attributes.
+
 ### Metadata
 
 ```
 class Metadata {
   // Whether the test case will be skipped by the test runner.
   bool skip;
 
   // The reason the test case is skipped, if the user provided it.
   String? skipReason;
 }
 ```
 
 The metadata attached to a test by a user.