Expand lane-crossing note in SIMD article with a worked example

[tannergooding]

What

Expands the lane-crossing [!NOTE] under "Cross-platform vectorization with Vector128" (added in #54834) into a worked example showing why lane-crossing operations don't widen for free on x86/x64, the way element-wise operations do.

Content added

• Two ASCII diagrams contrasting element-wise Add (same-index, width-agnostic) with a pairwise reduction (adjacent-index, width-sensitive).
• A verified C# snippet (LaneCrossingExample.cs) with three methods:
  • SumVector128: a correct two-round Sse3.HorizontalAdd reduction on Vector128<float>.
  • SumVector256Naive: the same two-round pattern naively extended to Vector256<float> -- compiles and runs, but only returns the lower lane's partial sum, not the full 8-element total, because Avx.HorizontalAdd repeats the pairwise pattern independently per 128-bit lane.
  • SumVector256: the fix, bridging the lane boundary explicitly with GetLower/GetUpper.
• A bit-layout diagram (128-bit element-width box) next to the intro paragraph, and a lower/upper split diagram next to the GetLower/GetUpper fix.
• Wired the three methods into Program.cs's verification runner.

Verification

net11.0 isn't available in this sandbox yet, so the LaneCrossingExample.cs logic was verified in an isolated scratch project targeting net10.0:

SumVector128       = 10 (expect 10)
SumVector256Naive  = 10 (expect 10, only lower lane)
SumVector256       = 110 (expect 110)

Numbers match the prose exactly ([1,2,3,4,10,20,30,40]: lower lane sums to 10, upper lane to 100, naive gives only 10, fixed gives 110).

Scope

Docs-only change to docs/standard/simd.md and the SimdSnippets snippet project. No build/test infra changes. Out of scope (not included here): worked examples for Widen/Narrow/Shuffle, which the article currently only covers in the reference table.

---

Internal previews

📄 File	🔗 Preview link
docs/standard/simd.md	Use SIMD and hardware intrinsics in .NET

[tannergooding]

@gewarren, I'm not sure how we feel about ASCII diagrams in the docs, but this is the bit that I had left out of #54834 and I noticed it when working to simplify the dotnet/runtime repo specific guidance

Gives a visual aid and explanation of one of the other common pitfalls.

[Copilot]

Pull request overview

This PR expands the SIMD documentation to better explain why lane-crossing (pairwise/horizontal) operations don’t automatically benefit from widening vectors on x86/x64, by adding diagrams and a worked, verified C# example using Vector128<float> and Vector256<float>.

Changes:

• Adds ASCII diagrams and an explanatory subsection demonstrating how element-wise operations differ from lane-sensitive horizontal reductions on x86/x64.
• Introduces a new snippet (LaneCrossingExample.cs) that contrasts a correct Vector128<float> horizontal reduction with a naïve Vector256<float> version and a corrected lane-bridging implementation.
• Updates the snippet verification runner to execute and print the new example outputs when supported.

Show a summary per file

File	Description
docs/standard/snippets/simd/csharp/Program.cs	Adds runtime-gated output for the new lane-crossing snippet methods in the verification runner.
docs/standard/snippets/simd/csharp/LaneCrossingExample.cs	New snippet showing correct and incorrect horizontal reduction patterns across 128-bit lanes on AVX.
docs/standard/simd.md	Expands the x86/x64 lane note into a worked example with diagrams and snippet references.

Copilot's findings

• Files reviewed: 3/3 changed files
• Comments generated: 2