Fix disabled filter handling: set value to null and continue chain

The previous fix used `continue` alone, but the non-chained path
propagates null through subsequent filters rather than skipping.
Setting value = null before continuing matches that behavior exactly.

Adds parity test confirming optimized and non-chained paths produce
identical output for disabled filters in a chain.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: hs-lsong

src/main/java/com/hubspot/jinjava/el/ext/AstFilterChain.java

@@ -85,6 +85,7 @@ public Object eval(Bindings bindings, ELContext context) {
             e
           )
         );
+        value = null;
         continue;
       }
       if (filter == null) {

src/test/java/com/hubspot/jinjava/el/ext/AstFilterChainTest.java

@@ -2,13 +2,19 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
 import com.hubspot.jinjava.Jinjava;
 import com.hubspot.jinjava.JinjavaConfig;
+import com.hubspot.jinjava.interpret.Context;
 import com.hubspot.jinjava.interpret.RenderResult;
+import com.hubspot.jinjava.interpret.TemplateError.ErrorItem;
+import com.hubspot.jinjava.interpret.TemplateError.ErrorReason;
 import com.hubspot.jinjava.objects.date.PyishDate;
 import java.time.ZonedDateTime;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Set;
 import org.junit.Before;
 import org.junit.Test;
 
@@ -106,4 +112,60 @@ public void itFallsBackToUnoptimizedForUnknownFilterParity() {
       .as("Optimized should match un-optimized for unknown filter in chain")
       .isEqualTo(unoptimizedResult.getOutput());
   }
+
+  @Test
+  public void itSkipsDisabledFilterAndContinuesChain() {
+    Map<Context.Library, Set<String>> disabled = ImmutableMap.of(
+      Context.Library.FILTER,
+      ImmutableSet.of("lower")
+    );
+    Jinjava jinjavaWithDisabled = new Jinjava(
+      JinjavaConfig
+        .newBuilder()
+        .withEnableFilterChainOptimization(true)
+        .withDisabled(disabled)
+        .build()
+    );
+
+    RenderResult result = jinjavaWithDisabled.renderForResult(
+      "{{ name|trim|lower|capitalize }}",
+      context
+    );
+
+    assertThat(result.getErrors()).isNotEmpty();
+    assertThat(result.getErrors().get(0).getItem()).isEqualTo(ErrorItem.FILTER);
+    assertThat(result.getErrors().get(0).getReason()).isEqualTo(ErrorReason.DISABLED);
+    assertThat(result.getErrors().get(0).getMessage()).contains("lower");
+  }
+
+  @Test
+  public void itMatchesNonChainedBehaviorForDisabledFilter() {
+    Map<Context.Library, Set<String>> disabled = ImmutableMap.of(
+      Context.Library.FILTER,
+      ImmutableSet.of("lower")
+    );
+    String template = "{{ name|trim|lower|capitalize }}";
+
+    Jinjava optimized = new Jinjava(
+      JinjavaConfig
+        .newBuilder()
+        .withEnableFilterChainOptimization(true)
+        .withDisabled(disabled)
+        .build()
+    );
+    Jinjava unoptimized = new Jinjava(
+      JinjavaConfig
+        .newBuilder()
+        .withEnableFilterChainOptimization(false)
+        .withDisabled(disabled)
+        .build()
+    );
+
+    RenderResult optimizedResult = optimized.renderForResult(template, context);
+    RenderResult unoptimizedResult = unoptimized.renderForResult(template, context);
+
+    assertThat(optimizedResult.getOutput())
+      .as("Optimized should match un-optimized for disabled filter in chain")
+      .isEqualTo(unoptimizedResult.getOutput());
+  }
 }