Implement BitString chaining mechanism for memory bandwidth optimization

[konard]

Summary

This PR implements a chaining mechanism for BitString operations that addresses issue #57 by allowing multiple operations to be applied in a single memory pass, significantly improving performance by reducing memory bandwidth limitations.

Problem

The original BitString implementation required separate memory passes for each operation. When applying multiple operations sequentially (e.g., bitString.Not().And(other1).Or(other2)), each operation would traverse the entire memory array independently, leading to:

• Inefficient memory bandwidth usage
• Poor cache performance on large BitStrings
• Suboptimal performance when chaining multiple operations

Solution

New BitStringChain class that:

• Accumulates multiple operations without immediate execution
• Applies all queued operations in a single memory traversal
• Maintains the same API contract and results as individual operations
• Uses a fluent interface for easy operation chaining

Key Features

• Single-pass execution: All operations applied in one memory traversal
• Complete operation support: AND, OR, XOR, and NOT operations
• Fluent API: Natural chaining syntax with .Chain()...Execute()
• Performance optimized: Direct internal array access for efficiency
• Memory efficient: No additional temporary arrays needed

Usage Examples

// Traditional approach (multiple memory passes)
var result1 = new BitString(source);
result1.Not();           // Pass 1
result1.And(other1);     // Pass 2  
result1.Or(other2);      // Pass 3
result1.Xor(other3);     // Pass 4

// Optimized approach (single memory pass)
var result2 = new BitString(source)
    .Chain()
    .Not()
    .And(other1)
    .Or(other2)
    .Xor(other3)
    .Execute();          // Single pass through memory

// Results are identical
Assert.True(result1.Equals(result2));

Performance Benefits

The chaining mechanism provides significant performance improvements especially for:

• Large BitStrings where memory bandwidth is the bottleneck
• Complex operation sequences with multiple steps
• Scenarios where cache locality matters (frequent operations)

Implementation Details

1. BitStringChain Class: Manages operation queue and single-pass execution
2. Internal API Extensions: Added internal methods to BitString for array access
3. Operation Abstraction: Each operation type implements a common interface
4. Memory Optimization: Works within existing memory borders for efficiency

Testing

• Comprehensive unit tests covering all operation combinations
• Performance benchmarks comparing traditional vs chained approaches
• Correctness validation ensuring identical results between approaches
• Edge case testing including empty operations and complex sequences

Files Changed

• Platform.Collections/BitStringChain.cs - New chaining implementation
• Platform.Collections/BitString.cs - Added internal API methods and Chain() entry point
• Platform.Collections.Tests/BitStringTests.cs - Comprehensive test coverage
• Platform.Collections.Benchmarks/BitStringBenchmarks.cs - Performance benchmarks
• examples/BitStringChainExample.cs - Usage demonstration

Test plan

• All existing BitString tests continue to pass
• New chaining tests verify correctness across all operation types
• Benchmark tests demonstrate performance improvements
• Build succeeds without errors
• Integration with existing codebase validated

🤖 Generated with Claude Code

---

Resolves #57