BUG: serialize numpy SeedSequence for sensor seeds (#1087) - #1124

`Sensor.__init__` passes the seed straight to `numpy.random.default_rng`,
which also accepts `Generator` and `BitGenerator` objects. The sensor then
constructs successfully and stores the object on `self._seed`, where
`to_dict()` emits it verbatim, so the failure only surfaces later at
`json.dumps()`, far from the call that caused it.

RocketPy-Team#1124 closed the `SeedSequence` case in RocketPy-Team#1087 by teaching `RocketPyEncoder`
to write one out. That works because a `SeedSequence` is defined by its
entropy and spawn key, so it still describes the stream after a round trip.
A `Generator` has no such description: its state advances on every draw, so
whatever `to_dict()` wrote would depend on when it ran, and restoring it
would not reproduce the stream the sensor actually used.

Reject those two in the constructor instead, so the failure stays at the
call that caused it. Ints, numpy ints, `SeedSequence` and `None` are
untouched, as are the sequences of ints `default_rng` accepts and the
encoder already serializes, so no seed that works today is rejected.

Annotate `seed` on every constructor that takes one, with the type the
issue itself names, so the contract is stated where the argument is
declared rather than only in the docstring.

`Sensor.__init__` passes the seed straight to `numpy.random.default_rng`,
which also accepts `Generator` and `BitGenerator` objects. The sensor then
constructs successfully and stores the object on `self._seed`, where
`to_dict()` emits it verbatim, so the failure only surfaces later at
`json.dumps()`, far from the call that caused it.

RocketPy-Team#1124 closed the `SeedSequence` case in RocketPy-Team#1087 by teaching `RocketPyEncoder`
to write one out. That works because a `SeedSequence` is defined by its
entropy and spawn key, so it still describes the stream after a round trip.
A `Generator` has no such description: its state advances on every draw, so
whatever `to_dict()` wrote would depend on when it ran, and restoring it
would not reproduce the stream the sensor actually used.

Reject those two in the constructor instead, so the failure stays at the
call that caused it. Ints, numpy ints, `SeedSequence` and `None` are
untouched, as are the sequences of ints `default_rng` accepts and the
encoder already serializes, so no seed that works today is rejected.

Annotate `seed` on every constructor that takes one, with the type the
issue itself names, so the contract is stated where the argument is
declared rather than only in the docstring.

* BUG: reject live RNG objects as Sensor seeds

`Sensor.__init__` passes the seed straight to `numpy.random.default_rng`,
which also accepts `Generator` and `BitGenerator` objects. The sensor then
constructs successfully and stores the object on `self._seed`, where
`to_dict()` emits it verbatim, so the failure only surfaces later at
`json.dumps()`, far from the call that caused it.

#1124 closed the `SeedSequence` case in #1087 by teaching `RocketPyEncoder`
to write one out. That works because a `SeedSequence` is defined by its
entropy and spawn key, so it still describes the stream after a round trip.
A `Generator` has no such description: its state advances on every draw, so
whatever `to_dict()` wrote would depend on when it ran, and restoring it
would not reproduce the stream the sensor actually used.

Reject those two in the constructor instead, so the failure stays at the
call that caused it. Ints, numpy ints, `SeedSequence` and `None` are
untouched, as are the sequences of ints `default_rng` accepts and the
encoder already serializes, so no seed that works today is rejected.

Annotate `seed` on every constructor that takes one, with the type the
issue itself names, so the contract is stated where the argument is
declared rather than only in the docstring.

* BUG: reject RandomState and other non-descriptor Sensor seeds

default_rng also accepts RandomState from NumPy 2.2 on, and RocketPy pins
no upper bound on numpy, so the previous isinstance list let it through to
the same late TypeError at json.dumps() that #1087 reported.

Check the stable half of the contract instead of enumerating the live types:
accept ints, array_like of ints and SeedSequence, and refuse the rest. A
seed kind numpy starts accepting later is now refused at construction rather
than reaching serialization.

Widen the annotation to the array_like integer contract the check actually
takes. It goes through a SeedLike union so the seven signatures stay inside
the line limit while help() and inspect.signature() still expand the members.

* TST: compare the noise stream across a seed round trip

The existing round-trip tests assert on the stored seed value, which would
still pass for a seed that survives JSON without naming the stream the
original sensor used. Draw from the restored sensor instead and compare it
against a fresh one built from the same seed, across the four descriptor
kinds the constructor accepts.

* BUG: refuse the seed shapes SeedSequence cannot take either

The seed check accepted a nested sequence of ints, on the stated grounds
that "numpy accepts as entropy just the same". It does not: SeedSequence
raises TypeError for a nested sequence and ValueError for an array of two
or more dimensions. Older NumPy let the nested form through, which is why
this passed under Python 3.10 and failed under 3.14, where a newer NumPy is
resolved -- the acceptance was never portable, and RocketPy sets no upper
bound on the dependency.

So _is_int_array_like now takes a flat sequence only, and an ndarray only
at ndim <= 1. Both refusals name the seed, where the NumPy messages they
replace name neither it nor the argument that carried it.

The nested case moves out of test_int_array_like_seeds_are_accepted and
into a rejection test alongside a 2-D array, which the check would have
admitted for the same reason.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Gui-FernandesBR <guilherme.fernandes@maggu.ai>
Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>