[API] Support np.where via ILKernelGenerator

[Nucs]

Summary

• Add IL-generated SIMD optimization for np.where(condition, x, y)
• Uses DynamicMethod to generate type-specific kernels at runtime
• Vector256/Vector128.ConditionalSelect for SIMD element selection
• 4x loop unrolling for instruction-level parallelism
• Native long indexing for large arrays
• Supports all 12 dtypes (11 via SIMD, Decimal via scalar fallback)

Implementation

Component	Description
WhereKernel<T>	Delegate type for IL-generated kernels
GetWhereKernel<T>()	Get/generate cached kernel
WhereExecute<T>()	Main entry with automatic fallback
Mask creation	Grouped by element size (1/2/4/8 bytes)

Eligibility for SIMD Path

bool canUseKernel = ILKernelGenerator.Enabled &&
                    cond.typecode == NPTypeCode.Boolean &&
                    cond.Shape.IsContiguous &&
                    xArr.Shape.IsContiguous &&
                    yArr.Shape.IsContiguous;

Falls back to iterator path for:

• Non-contiguous/broadcasted arrays
• Non-bool conditions (need truthiness conversion)

Test Plan

• 26 new WhereSimdTests for SIMD correctness
• 36 existing np_where_Test pass
• 21 battle tests pass
• All 12 dtypes covered

Closes #604

[Nucs]

Performance Results: AVX2 Mask Expansion Optimization

After implementing AVX2/SSE4.1 intrinsics for mask expansion, here are the benchmark results:

Kernel Performance (double, 1M elements)

Metric	Value
Kernel time	2.62 ms
Throughput	381 M elements/ms
NumPy baseline	~1.86 ms
Ratio vs NumPy	~1.4x slower

Scaling

Size	Kernel (ms)	Throughput
1K	0.0024	416 M/ms
10K	0.027	368 M/ms
100K	0.28	356 M/ms
1M	2.62	381 M/ms

How It Works

Replaced scalar conditional mask creation with single-instruction SIMD expansion:

// Before: 4 scalar conditionals for 8-byte elements
Vector256.Create(
    bools[0] != 0 ? 0xFFFFFFFFFFFFFFFFul : 0ul,
    bools[1] != 0 ? 0xFFFFFFFFFFFFFFFFul : 0ul,
    bools[2] != 0 ? 0xFFFFFFFFFFFFFFFFul : 0ul,
    bools[3] != 0 ? 0xFFFFFFFFFFFFFFFFul : 0ul
);

// After: 2-3 instructions using AVX2
var bytes128 = Vector128.CreateScalar(*(uint*)bools).AsByte();
var expanded = Avx2.ConvertToVector256Int64(bytes128).AsUInt64();  // vpmovzxbq
return Vector256.GreaterThan(expanded, Vector256<ulong>.Zero);

Element Size	Intrinsic	Effect
8 bytes	vpmovzxbq	4 bytes → 4 qwords
4 bytes	vpmovzxbd	8 bytes → 8 dwords
2 bytes	vpmovzxbw	16 bytes → 16 words

All 12 dtypes supported with scalar fallback for non-AVX2/SSE4.1 systems.

[Nucs]

Update: Inlined IL - Now 3.9x FASTER than NumPy!

By inlining the mask creation directly in IL instead of calling helper methods:

Version	Kernel Time	vs NumPy
With method Call	2.6 ms	1.4x slower
Inlined IL	0.48 ms	3.9x faster
NumPy	1.86 ms	baseline

What Changed

Instead of emitting Call opcodes to mask helper methods, the IL now emits the full AVX2 instruction sequence inline:

ldind.u4           ; Load 4 bool bytes
call CreateScalar  ; Put in Vector128
call AsByte        ; Reinterpret
call vpmovzxbq     ; AVX2 zero-extend bytes to qwords
call AsUInt64      ; Reinterpret  
call get_Zero      ; Vector256<ulong>.Zero
call GreaterThan   ; Create mask

This eliminates:

• Method call overhead (~12%)
• Runtime Avx2.IsSupported checks in hot path
• JIT optimization barriers at call boundaries

The kernel now processes 2,083 million elements per second - significantly faster than NumPy's ~540 M/ms.