BEGIN_PUBLIC
[Stdlib] Improve variadic filtering API and add comprehensive tests

Updates the variadic filtering utilities to use variadic parameters for a more
ergonomic API, and adds comprehensive test coverage:

API improvements:
- Changed from `element_types=...` to `*element_types` variadic parameters
- Renamed `Trait` to `T` to match stdlib conventions (consistent with
  `Variadic.types`, `Variadic.slice_types`, etc.)
- Simplified parameter names: `type` instead of `exclude_type` for single exclusions

Usage is now more concise:
```mojo
// Before
Variadic.exclude_type[exclude_type=Int, element_types=MyTypes]

// After
Variadic.exclude_type[*MyTypes, type=Int]
```

Tests added:
- `test_exclude_type()` - Remove a single type from a variadic
- `test_keep_types()` - Keep only specified types
- `test_exclude_types()` - Remove multiple types
- `test_filtering_chained()` - Chain multiple filtering operations
END_PUBLIC

BEGIN_PUBLIC
[Stdlib] Replace specialized filters with generic filter_types

Replaces the three specialized filtering functions (`exclude_type`, `keep_types`,
`exclude_types`) with a single generic `filter_types` function that accepts a
user-defined predicate.

Implementation:
- Added `_TypePredicateGenerator[T]` - Generator type for predicates that take
  a type and return Bool
- Added `_FilterReducer` - Generic reducer that filters based on any predicate
- Added `Variadic.filter_types[*types, predicate=...]` - Public API

This design is more flexible and composable than having separate specialized
functions. Users can write any filtering logic they need:

```mojo
# Exclude a single type
comptime IsNotInt[Type: Movable] = not _type_is_eq[Type, Int]()
comptime Filtered = Variadic.filter_types[*MyTypes, predicate=IsNotInt]

# Keep only specific types
comptime IsNumeric[Type: Movable] = (
    _type_is_eq[Type, Int]() or _type_is_eq[Type, Float64]()
)
comptime Numeric = Variadic.filter_types[*MyTypes, predicate=IsNumeric]

# Exclude multiple types
comptime NotIntOrBool[Type: Movable] = (
    not _type_is_eq[Type, Int]() and not _type_is_eq[Type, Bool]()
)
comptime Filtered = Variadic.filter_types[*MyTypes, predicate=NotIntOrBool]
```

Tests include filtering to exclude single types, keep only specific types,
exclude multiple types, and chaining filter operations.
END_PUBLIC