Fix OverflowException in Average() for int type by using long accumulator

[prozolic]

Summary

In the following, when executing Average() with large values in enumeration patterns, System.Linq does not throw an exception, but ZLinq throws an OverflowException. Therefore, I fixed the code so that for int type only, the sum calculation is performed using double, matching System.Linq's behavior.

Reproduction Steps

var largeValues = new[] { int.MaxValue / 2, int.MaxValue / 2, int.MaxValue / 2 };
var expected = ToEnumerable(largeValues).Average();
var actual = ToEnumerable(largeValues).AsValueEnumerable().Average();

static IEnumerable<T> ToEnumerable<T>(IEnumerable<T> source)
{
    foreach (var item in source)
    {
        yield return item;
    }
}

Expected behavior

Calculated without throwing an error.

Actual behavior

OverflowException is thrown.

Statck trace

System.OverflowException: Arithmetic operation resulted in an overflow.
   at System.Int32.System.Numerics.IAdditionOperators<System.Int32,System.Int32,System.Int32>.op_CheckedAddition(Int32 left, Int32 right)
   at ZLinq.ValueEnumerableExtensions.Average[TEnumerator,TSource](ValueEnumerable`2 source)
   at Program.<Main>$(String[] args)

[Copilot]

Pull request overview

This PR fixes an OverflowException that occurs when calculating Average() for int types with large values in ZLinq, bringing behavior in line with System.Linq. The fix uses a long accumulator instead of int to prevent overflow when summing large integer values.

Changes:

• Modified Average() implementations to accumulate int values using long instead of int
• Added tests to verify overflow protection for both nullable and non-nullable int sequences
• Applied fix across all code paths: NET8_0_OR_GREATER and pre-NET8, for both span-based and enumerator-based implementations

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated 1 comment.

File	Description
tests/ZLinq.Tests/Linq/AverageTest.cs	Added OverflowProtection test with 3 large int values and Nullable_OverflowProtection test with nullable ints to verify the fix
src/ZLinq/Linq/Average.cs	Updated all int-specific Average() implementations (both nullable and non-nullable, across NET8 and pre-NET8 paths) to use long accumulator instead of int

[neuecc]

Thank you!
I think that's a good solution!