Feat: add Go 1.18+ generic implementation with better performance

[HuKeping]

Summary

Add a generic implementation of Red-Black tree using Go 1.18+ type parameters, while maintaining full backward compatibility with existing code.

Motivation

The current implementation uses the Item interface, which has several limitations:

• Runtime type assertions that can panic
• No compile-time type safety
• Interface dispatch overhead affecting performance

Changes

1. Go version bumped to 1.18 - Required for generics support
2. New GenericRbtree[T] type - Type-safe red-black tree with Lessable[T] constraint
3. Improved API - Get/Delete/Min/Max return (value, bool) for explicit success indication
4. New methods - Contains() for existence check, Clear() for bulk removal, ForEach() for full traversal
5. Comprehensive tests - 13 new tests covering all generic operations
6. Benchmarks - Performance comparison between legacy and generic implementations

Performance Results

Benchmarked on Intel Xeon Gold 6266C @ 3.00GHz:

Operation	Legacy	Generic	Improvement
Insert	424.7 ns/op	363.5 ns/op	+14.4%
Get	95.24 ns/op	65.78 ns/op	+30.9%
Delete	325.0 ns/op	232.2 ns/op	+28.6%
Ascend	844.2 ns/op	786.1 ns/op	+6.9%
Mixed	610.8 ns/op	512.0 ns/op	+16.2%

Memory allocation reduction:

• Get: 100% less (5B → 0B, 0 allocs)
• Delete: 55% less (107B/3allocs → 48B/1alloc)
• Mixed: 23% less (62B/2allocs → 48B/1alloc)

Backward Compatibility

✅ All existing code continues to work without changes ─
✅ Legacy Rbtree implementation unchanged
✅ New GenericRbtree is opt-in

Usage Example

// Define type with Less method                           
type MyID int64                                                                                                                                                                            
func (x MyID) Less(y MyID) bool { return x < y }                                                                                                                                           
                                                                                                                                                                                           
// Use generic tree                                                                                                                                                                        
tree := rbtree.NewGeneric[MyID]()                                                                                                                                                          
tree.Insert(123)                                                                                                                                                                           
val, ok := tree.Get(123)  // Type-safe, returns (value, found)                                                                                                                             
tree.Contains(123)         // Explicit existence check                                                                                                                                     
tree.Clear()               // Bulk removal                                                                                                                                                 
                                                                                                                                                                                           
Test Plan                                                                                                                                                                                  
                                                                                                                                                                                           
- All existing tests pass (13 tests)                                                                                                                                                       
- New generic tests pass (13 tests)                       
- Benchmarks show performance improvement                                                                                                                                                  
- Review type constraint design (Lessable[T])                                                                                                                                              
- Consider adding more type utilities (e.g., Int64, String with built-in Less)                                                                                                             
                                                                                                                                                                                           
Notes                                                                                                                                                                                      
                                                                                                                                                                                           
- Generic version is faster due to compile-time monomorphization (no interface dispatch)                                                                                                   
- Min/Max slightly slower (~6%) due to (T, bool) return overhead, but negligible (<8ns)
- With help of Claude Code for initial implementation