refactor: migrate rand and arbitrary

[peter-jerry-ye]

Goal

Make Arbitrary accept general generators

Blocking issue

Currently the Arbitrary uses @splitmix.RandomState

1. All its methods need to be provided by the successor (&Source or Rand).
2. The import of package @random must be added.
3. There's the split method that is used and can not be replaced, resulting in
4. The behavior would be different, breaking all the expectation tests.

[peter-jerry-ye-code-review]

Trait constraint change in arbitrary type signature may affect existing code

Category
Correctness
Code Snippet
arbitrary(Int, @splitmix.RandomState) -> Self
// changed to:
arbitrary(Int, &@random.Source) -> Self
Recommendation
Ensure all existing implementations of Arbitrary are updated to handle the new Source trait interface instead of RandomState directly
Reasoning
The signature change from concrete RandomState to abstract Source type is a breaking change that could cause compilation errors in existing code that implements Arbitrary trait

Arbitrary implementations for collection types should be documented

Category
Maintainability
Code Snippet
pub impl[X : Arbitrary] Arbitrary for Array[X] with arbitrary(size, rs) {
let len = if size == 0 { 0 } else { rs.next_positive_int() % size }
Array::makei(len, fn(x) { X::arbitrary(x, rs) })
}
Recommendation
Add documentation comments explaining the generation strategy for collection types, including any invariants maintained during generation
Reasoning
Collection type generation behavior affects testing outcomes and should be well documented for users implementing property-based tests

Unnecessary allocation in View arbitrary implementation

Category
Performance
Code Snippet
pub impl[A : Arbitrary] Arbitrary for @array.View[A] with arbitrary(size, rs) {
(Arbitrary::arbitrary(size, rs) : Array[A])[:]
}
Recommendation
Consider implementing View generation directly without creating an intermediate Array
Reasoning
Creating a full Array just to get a View creates unnecessary allocation overhead. A direct implementation could be more efficient.