feat: add Fluent API support for all Redis implementations

Add fluent API builders for all Redis-backed Bloom Filter implementations:

1. FilterRedisBuilder (StackExchange.Redis):
   - WithRedisConnection(string/ConfigurationOptions/IConnectionMultiplexer)
   - WithRedisBitOperate(IRedisBitOperate)
   - WithRedisKey(string)
   - BuildRedis() / BuildRedisWithCapacity()

2. FilterCSRedisBuilder (CSRedisCore):
   - WithRedisClient(CSRedisClient)
   - WithRedisKey(string)
   - BuildCSRedis() / BuildCSRedisWithCapacity()

3. FilterFreeRedisBuilder (FreeRedis):
   - WithRedisClient(RedisClient)
   - WithRedisKey(string)
   - BuildFreeRedis() / BuildFreeRedisWithCapacity()

4. FilterEasyCachingBuilder (EasyCaching):
   - WithRedisCachingProvider(IRedisCachingProvider)
   - WithRedisKey(string)
   - BuildEasyCaching() / BuildEasyCachingWithCapacity()

All builders inherit from FilterBuilder to support common configuration:
- WithName() - Set filter name
- ExpectingElements() - Set expected element count
- WithErrorRate() - Set false positive rate
- UsingHashMethod() / UsingCustomHash() - Configure hash functions
- WithSerializer() - Set custom serializer (FilterBuilder only)

Changed FilterBuilder base class fields from private to protected
to enable inheritance by Redis builders.

Example usage:
var filter = FilterRedisBuilder.Create()
    .WithRedisConnection("localhost:6379")
    .WithRedisKey("bloom:users")
    .WithName("UserFilter")
    .ExpectingElements(10_000_000)
    .WithErrorRate(0.001)
    .UsingHashMethod(HashMethod.XXHash3)
    .BuildRedis();

All 239 tests passing ✅

Author: vla

src/BloomFilter.CSRedis/FilterCSRedisBuilder.cs

@@ -0,0 +1,102 @@
+using CSRedis;
+using System;
+
+namespace BloomFilter.CSRedis;
+
+/// <summary>
+/// BloomFilter CSRedis Builder - Supports both static factory methods and fluent API
+/// </summary>
+/// <example>
+/// Fluent API:
+/// <code>
+/// var filter = FilterCSRedisBuilder.Create()
+///     .WithRedisClient(csredisClient)
+///     .WithRedisKey("bloom:users")
+///     .WithName("UserFilter")
+///     .ExpectingElements(10_000_000)
+///     .WithErrorRate(0.001)
+///     .UsingHashMethod(HashMethod.XXHash3)
+///     .BuildCSRedis();
+/// </code>
+/// </example>
+public class FilterCSRedisBuilder : FilterBuilder
+{
+    #region Fluent API - Instance Members
+
+    private string? _redisKey;
+    private CSRedisClient? _client;
+
+    /// <summary>
+    /// Sets the Redis key for the Bloom Filter
+    /// </summary>
+    /// <param name="redisKey">The Redis key</param>
+    /// <returns>The builder for method chaining</returns>
+    /// <exception cref="ArgumentException">Thrown when redisKey is null or whitespace</exception>
+    public FilterCSRedisBuilder WithRedisKey(string redisKey)
+    {
+        if (string.IsNullOrWhiteSpace(redisKey))
+            throw new ArgumentException("Redis key cannot be null or whitespace", nameof(redisKey));
+        _redisKey = redisKey;
+        return this;
+    }
+
+    /// <summary>
+    /// Sets the CSRedis client
+    /// </summary>
+    /// <param name="client">The CSRedisClient instance</param>
+    /// <returns>The builder for method chaining</returns>
+    /// <exception cref="ArgumentNullException">Thrown when client is null</exception>
+    public FilterCSRedisBuilder WithRedisClient(CSRedisClient client)
+    {
+#if NET6_0_OR_GREATER
+        ArgumentNullException.ThrowIfNull(client);
+#else
+        if (client == null)
+            throw new ArgumentNullException(nameof(client));
+#endif
+        _client = client;
+        return this;
+    }
+
+    /// <summary>
+    /// Builds a CSRedis-backed Bloom Filter with the configured settings
+    /// </summary>
+    /// <returns>A new IBloomFilter instance backed by CSRedis</returns>
+    /// <exception cref="InvalidOperationException">Thrown when required configuration is missing</exception>
+    public IBloomFilter BuildCSRedis()
+    {
+        if (string.IsNullOrWhiteSpace(_redisKey))
+            throw new InvalidOperationException("Redis key must be specified using WithRedisKey()");
+
+        if (_client == null)
+            throw new InvalidOperationException("CSRedis client must be specified using WithRedisClient()");
+
+        // Get hash function from base class configuration
+        var hashFunction = _customHashFunction ?? HashFunction.Functions[_method];
+
+        return new FilterCSRedis(_name, _client, _redisKey!, _expectedElements, _errorRate, hashFunction);
+    }
+
+    /// <summary>
+    /// Builds a CSRedis-backed Bloom Filter with explicit capacity and hash count (advanced usage)
+    /// </summary>
+    /// <param name="capacity">The bit array capacity</param>
+    /// <param name="hashes">The number of hash functions</param>
+    /// <returns>A new IBloomFilter instance backed by CSRedis</returns>
+    /// <exception cref="InvalidOperationException">Thrown when required configuration is missing</exception>
+    public IBloomFilter BuildCSRedisWithCapacity(long capacity, int hashes)
+    {
+        if (string.IsNullOrWhiteSpace(_redisKey))
+            throw new InvalidOperationException("Redis key must be specified using WithRedisKey()");
+
+        if (_client == null)
+            throw new InvalidOperationException("CSRedis client must be specified using WithRedisClient()");
+
+        // Get hash function from base class configuration
+        var hashFunction = _customHashFunction ?? HashFunction.Functions[_method];
+
+        return new FilterCSRedis(_name, _client, _redisKey!, capacity, hashes, hashFunction);
+    }
+
+    #endregion
+}

src/BloomFilter.EasyCaching/FilterEasyCachingBuilder.cs

@@ -0,0 +1,102 @@
+using EasyCaching.Core;
+using System;
+
+namespace BloomFilter.EasyCaching;
+
+/// <summary>
+/// BloomFilter EasyCaching Builder - Supports both static factory methods and fluent API
+/// </summary>
+/// <example>
+/// Fluent API:
+/// <code>
+/// var filter = FilterEasyCachingBuilder.Create()
+///     .WithRedisCachingProvider(provider)
+///     .WithRedisKey("bloom:users")
+///     .WithName("UserFilter")
+///     .ExpectingElements(10_000_000)
+///     .WithErrorRate(0.001)
+///     .UsingHashMethod(HashMethod.XXHash3)
+///     .BuildEasyCaching();
+/// </code>
+/// </example>
+public class FilterEasyCachingBuilder : FilterBuilder
+{
+    #region Fluent API - Instance Members
+
+    private string? _redisKey;
+    private IRedisCachingProvider? _provider;
+
+    /// <summary>
+    /// Sets the Redis key for the Bloom Filter
+    /// </summary>
+    /// <param name="redisKey">The Redis key</param>
+    /// <returns>The builder for method chaining</returns>
+    /// <exception cref="ArgumentException">Thrown when redisKey is null or whitespace</exception>
+    public FilterEasyCachingBuilder WithRedisKey(string redisKey)
+    {
+        if (string.IsNullOrWhiteSpace(redisKey))
+            throw new ArgumentException("Redis key cannot be null or whitespace", nameof(redisKey));
+        _redisKey = redisKey;
+        return this;
+    }
+
+    /// <summary>
+    /// Sets the EasyCaching Redis caching provider
+    /// </summary>
+    /// <param name="provider">The IRedisCachingProvider instance</param>
+    /// <returns>The builder for method chaining</returns>
+    /// <exception cref="ArgumentNullException">Thrown when provider is null</exception>
+    public FilterEasyCachingBuilder WithRedisCachingProvider(IRedisCachingProvider provider)
+    {
+#if NET6_0_OR_GREATER
+        ArgumentNullException.ThrowIfNull(provider);
+#else
+        if (provider == null)
+            throw new ArgumentNullException(nameof(provider));
+#endif
+        _provider = provider;
+        return this;
+    }
+
+    /// <summary>
+    /// Builds an EasyCaching-backed Bloom Filter with the configured settings
+    /// </summary>
+    /// <returns>A new IBloomFilter instance backed by EasyCaching</returns>
+    /// <exception cref="InvalidOperationException">Thrown when required configuration is missing</exception>
+    public IBloomFilter BuildEasyCaching()
+    {
+        if (string.IsNullOrWhiteSpace(_redisKey))
+            throw new InvalidOperationException("Redis key must be specified using WithRedisKey()");
+
+        if (_provider == null)
+            throw new InvalidOperationException("Redis caching provider must be specified using WithRedisCachingProvider()");
+
+        // Get hash function from base class configuration
+        var hashFunction = _customHashFunction ?? HashFunction.Functions[_method];
+
+        return new FilterEasyCachingRedis(_name, _provider, _redisKey!, _expectedElements, _errorRate, hashFunction);
+    }
+
+    /// <summary>
+    /// Builds an EasyCaching-backed Bloom Filter with explicit capacity and hash count (advanced usage)
+    /// </summary>
+    /// <param name="capacity">The bit array capacity</param>
+    /// <param name="hashes">The number of hash functions</param>
+    /// <returns>A new IBloomFilter instance backed by EasyCaching</returns>
+    /// <exception cref="InvalidOperationException">Thrown when required configuration is missing</exception>
+    public IBloomFilter BuildEasyCachingWithCapacity(long capacity, int hashes)
+    {
+        if (string.IsNullOrWhiteSpace(_redisKey))
+            throw new InvalidOperationException("Redis key must be specified using WithRedisKey()");
+
+        if (_provider == null)
+            throw new InvalidOperationException("Redis caching provider must be specified using WithRedisCachingProvider()");
+
+        // Get hash function from base class configuration
+        var hashFunction = _customHashFunction ?? HashFunction.Functions[_method];
+
+        return new FilterEasyCachingRedis(_name, _provider, _redisKey!, capacity, hashes, hashFunction);
+    }
+
+    #endregion
+}

src/BloomFilter.FreeRedis/FilterFreeRedisBuilder.cs

@@ -0,0 +1,102 @@
+using FreeRedis;
+using System;
+
+namespace BloomFilter.FreeRedis;
+
+/// <summary>
+/// BloomFilter FreeRedis Builder - Supports both static factory methods and fluent API
+/// </summary>
+/// <example>
+/// Fluent API:
+/// <code>
+/// var filter = FilterFreeRedisBuilder.Create()
+///     .WithRedisClient(redisClient)
+///     .WithRedisKey("bloom:users")
+///     .WithName("UserFilter")
+///     .ExpectingElements(10_000_000)
+///     .WithErrorRate(0.001)
+///     .UsingHashMethod(HashMethod.XXHash3)
+///     .BuildFreeRedis();
+/// </code>
+/// </example>
+public class FilterFreeRedisBuilder : FilterBuilder
+{
+    #region Fluent API - Instance Members
+
+    private string? _redisKey;
+    private RedisClient? _client;
+
+    /// <summary>
+    /// Sets the Redis key for the Bloom Filter
+    /// </summary>
+    /// <param name="redisKey">The Redis key</param>
+    /// <returns>The builder for method chaining</returns>
+    /// <exception cref="ArgumentException">Thrown when redisKey is null or whitespace</exception>
+    public FilterFreeRedisBuilder WithRedisKey(string redisKey)
+    {
+        if (string.IsNullOrWhiteSpace(redisKey))
+            throw new ArgumentException("Redis key cannot be null or whitespace", nameof(redisKey));
+        _redisKey = redisKey;
+        return this;
+    }
+
+    /// <summary>
+    /// Sets the FreeRedis client
+    /// </summary>
+    /// <param name="client">The RedisClient instance</param>
+    /// <returns>The builder for method chaining</returns>
+    /// <exception cref="ArgumentNullException">Thrown when client is null</exception>
+    public FilterFreeRedisBuilder WithRedisClient(RedisClient client)
+    {
+#if NET6_0_OR_GREATER
+        ArgumentNullException.ThrowIfNull(client);
+#else
+        if (client == null)
+            throw new ArgumentNullException(nameof(client));
+#endif
+        _client = client;
+        return this;
+    }
+
+    /// <summary>
+    /// Builds a FreeRedis-backed Bloom Filter with the configured settings
+    /// </summary>
+    /// <returns>A new IBloomFilter instance backed by FreeRedis</returns>
+    /// <exception cref="InvalidOperationException">Thrown when required configuration is missing</exception>
+    public IBloomFilter BuildFreeRedis()
+    {
+        if (string.IsNullOrWhiteSpace(_redisKey))
+            throw new InvalidOperationException("Redis key must be specified using WithRedisKey()");
+
+        if (_client == null)
+            throw new InvalidOperationException("FreeRedis client must be specified using WithRedisClient()");
+
+        // Get hash function from base class configuration
+        var hashFunction = _customHashFunction ?? HashFunction.Functions[_method];
+
+        return new FilterFreeRedis(_name, _client, _redisKey!, _expectedElements, _errorRate, hashFunction);
+    }
+
+    /// <summary>
+    /// Builds a FreeRedis-backed Bloom Filter with explicit capacity and hash count (advanced usage)
+    /// </summary>
+    /// <param name="capacity">The bit array capacity</param>
+    /// <param name="hashes">The number of hash functions</param>
+    /// <returns>A new IBloomFilter instance backed by FreeRedis</returns>
+    /// <exception cref="InvalidOperationException">Thrown when required configuration is missing</exception>
+    public IBloomFilter BuildFreeRedisWithCapacity(long capacity, int hashes)
+    {
+        if (string.IsNullOrWhiteSpace(_redisKey))
+            throw new InvalidOperationException("Redis key must be specified using WithRedisKey()");
+
+        if (_client == null)
+            throw new InvalidOperationException("FreeRedis client must be specified using WithRedisClient()");
+
+        // Get hash function from base class configuration
+        var hashFunction = _customHashFunction ?? HashFunction.Functions[_method];
+
+        return new FilterFreeRedis(_name, _client, _redisKey!, capacity, hashes, hashFunction);
+    }
+
+    #endregion
+}