This method makes it possible to create an initial valid result set for use in populating a form.
Having this method makes the following possible:

```php
<?php $form = $ruleSet->createValidResultSet(); ?>

<!-- In a template: -->
<input type="text" name="first" value="<?= $this->e($form->first->value) ?>" />
<?php if (! $form->first->isValid): ?>
<p class="text-danger">The value you provided is invalid: <?= $this->e($form->first->message) ?></p>
<?php endif ?>
```

To make the tests work, I also needed to provide an `__isset()` implementation for `ResultSet`.

Rounds out remaining functionality of `createValidResultSet()`:

- ResultSet MUST NOT contain mappings for any `$valueMap` keys NOT in the rule set
- ResultSet MUST use `null` for any OPTIONAL rules with no default value set
- ResultSet MUST raise an exception if a key does not exist in the `$valueMap`, maps to a required rule, but has no default value.
  - Adds `RequiredRuleWithNoDefaultValueException` as the exception type for this
- Method MUST create a `ResultSet` of the type provided in `$resultSetClass` if a class was provided.
  - This required making the `ResultSet` class non-final; all methods were marked final, however.

To make this functionality more predictable and useful to developers:

- Updated `Result` to add a `@template T` annotation, and assigns `@var T` to the `$value` property.
- This allows the following patterns:
  - Extending `ResultSet` and defining `@property(-read)` mappings:

    ```php
    /**
     * @property-read Result<int> $count
     * @property-read Result<string> $title
     */
    class CustomResultSet extends ResultSet { }
    ```

  - Providing a template for a returned result set:

    ```php
    /** @var ResultSet{count: Result<int>, title: Result<string>} $form */
    ```

- Moves the definition of a custom result set class to use with a rule set to a new named constructor, `RuleSet::createWithResultSetClass()`.
  - This means that for the 80% use case, you will just use the constructor, with or without rules.
  - When you want to specify a custom result set class to use, use the named constructor.

- You can provide Psalm/PHPStan hints when creating a ResultSet or RuleSet

  ```php
  /** @var RuleSet<ResultSet> $ruleSet */
  $ruleSet = new RuleSet();

  /** @var ResultSet{title: string, description: string, createdDate: DateTimeImmutable} $result */
  $result = $ruleSet->validate($data);
  ```

- Makes `RuleSet::$resultSetClass` protected, to simplify extension.
- Documents how to provide types for results, result sets, and rule sets via template annotations.

Documents it and provides some examples.

- Removes `final` and `readonly` keywords from `Result`.
  - All properties are marked readonly
  - All methods are marked final
  - Named constructors use `static` when creating new instances, and `@return Result<T>`
  - constructor is made protected and marked final, to allow Psalm to validate that the named constructors will work with the class constructor
- `NestedResult` extends `Result, and adds `__isset()` and `__get()` implementations that check for nested result sets and the properties it defines.