…ndows

This only happens in test runs, since real test name always start with 'Test'

This allows reuse actions from normal tests that use `testing.TB`.

This is helpful for tests where there may be very specific test
scenarios where some logic is abstracted into a common action.

See #67.

Go 1.24 was released last week.
Test against Go 1.24 in CI as well.

(Per Go support policy, 1.21 and 1.22 are no longer supported,
but I've left them around as rapid may still want to support them.)

* feat: Add T.Context()

*Context*:
Go 1.24 adds a `Context()` method to `testing.TB` that returns
a context bound to the current test's lifetime.
The context becomes invalid _before_ `T.Cleanup` functions are run.

*Details*:
This change adds a similar `Context()` method to `rapid.T`,
except this context is only valid for the duration of one iteration
of a rapid check.

*Implementation notes*:
This changes `newT` to return a `cancel` function
instead of just adding a `cancel` method to `T`
to ensure that all callers of `newT` remember to call `cancel`.

This also uses IIFEs (immediately-invoked function expressions)
in a couple places to rely on well-timed `defer` calls for cleanup
instead of manually calling `cancel`.

*Future work*:
The logic added in this commit will make it relatively straightforward
to add a `Cleanup` method (#62).

* lazy init, cleanup in checkOnce, maybeValue, example

Per GitHub comment, delete the `cancel` return value from newT,
instead add a single `cleanup` method.

The method is called for cleanup in three places:

- checkOnce: this is per property
- maybeValue: this is per Custom generator function call
- example: this is per Example call

Context is now initialized lazily:
if there isn't one, it is created.

* fix: data race in t.ctx access

* feat: Add T.Cleanup

Adds a new T.Cleanup method to register cleanup functions.
These will run after each iteration of a Check.

The implementation of how cleanup functions are tracked and run
is borrowed heavily from testing.T's own implementation.
Namely:

- [T.Cleanup puts functions in a slice](https://cs.opensource.google/go/go/+/refs/tags/go1.24.0:src/testing/testing.go;l=1214-1216)
- [cleanups are run in reverse order](https://cs.opensource.google/go/go/+/refs/tags/go1.24.0:src/testing/testing.go;l=1433-1446)
  popping functions from the slice one by one
- [panics are not allowed to interrupt cleanup](https://cs.opensource.google/go/go/+/refs/tags/go1.24.0:src/testing/testing.go;l=1420-1427)

As with `testing.T`, cleanup runs after the context is canceled.
Because Rapid's context is lazily initialized,
it needs an additional check to avoid providing a valid context
during cleanup.

Resolves #62

* doc: try to be clearer