Fixes#57272
cc:@GrabYourPitchforks,@tannergooding

When we introduced the new Random algorithm, we did so by factoring the old algorithm out into an implementation strategy class that is instantiated for all use other thannew Random(). This ends up penalizing other uses (providing a seed and/or deriving from Random) by adding more virtual dispatch than is strictly necessary, in particular fornew Random(seed). This PR negates most but not all of that (expected and small) regression by splitting the compat implementation in two, one class fornew Random(seed) and one fornew DerivedRandom()/new DerivedRandom(seed); the former no longer needs to make virtual calls back out to the parent type. The former is also one that a consumer can't really do anything to improve, whereas in the derived case, the derivation may override to provide a more optimal implementation.

Additionally, we introduced NextInt64 in this release, which means we can still change the algorithm it uses / what derived methods it calls. This changes the implementation to make 3 calls instead of 8.

I also experimented but ultimately decided against the proposal in the cited issue to lazily-initialize the array for a derived type the first time it uses the state. The lazy initialization was measurable, and most derived types I found do end up using one of the base methods (even though obviously it could be used purely as an abstraction). We can reconsider in the future.

publicclassRandomSeed:TestBase{publicoverrideRandomCreate()=>newRandom(42);}publicclassRandomDerived:TestBase{publicoverrideRandomCreate()=>newDerivedRandom();privatesealedclassDerivedRandom:Random{}}publicabstractclassTestBase{privatebyte[]_buffer=newbyte[10_000];privateRandom_random;publicabstractRandomCreate();[GlobalSetup]publicvoidSetup()=>_random=Create();[Benchmark]publicRandomCtor()=>Create();[Benchmark]publicintNext()=>_random.Next();[Benchmark]publicvoidNextMax()=>_random.Next(42);[Benchmark]publicvoidNextMinMax()=>_random.Next(0,42);[Benchmark]publicvoidNextInt64()=>_random.NextInt64();[Benchmark]publicvoidNextInt64Max()=>_random.NextInt64(42);[Benchmark]publicvoidNextInt64MinMax()=>_random.NextInt64(0,42);[Benchmark]publicvoidNextSingle()=>_random.NextSingle();[Benchmark]publicvoidNextDouble()=>_random.NextDouble();[Benchmark]publicvoidNextBytesArray()=>_random.NextBytes(_buffer);[Benchmark]publicvoidNextBytesSpan()=>_random.NextBytes((Span<byte>)_buffer);}

I'm not currently sure whyNextBytesArray gets a little slower... that'll need more investigation.