servlet: fix TomcatTransportTest detects write when not ready (#12732)

Fixes #12723 

### What was happening
In `AsyncServletOutputStreamWriter#runOrBuffer`, the application thread
relies on the cached `readyAndDrained `state to determine if it can
write directly to the `ServletOutputStream`.

In highly concurrent scenarios (observed in `TomcatTransportTest`), this
cached state can become stale. The servlet container may have already
transitioned to a 'not ready' state, but the corresponding callback has
not yet updated gRPC's internal state. When the application thread
attempts to write based on the stale `true `value, the container throws
an `IllegalStateException`.

### The Fix
This PR updates the primary execution path in `runOrBuffer` to
explicitly evaluate `isReady.getAsBoolean()` alongside the cached state.

If the cached state is true but the container is actually not ready, the
thread gracefully drops into the `else` block, buffers the action into
the `writeChain`, and attempts to update `readyAndDrained` to `false`.

Author: themechbro

servlet/src/main/java/io/grpc/servlet/AsyncServletOutputStreamWriter.java

@@ -78,6 +78,7 @@ final class AsyncServletOutputStreamWriter {
   private final Queue<ActionItem> writeChain = new ConcurrentLinkedQueue<>();
   // for a theoretical race condition that onWritePossible() is called immediately after isReady()
   // returns false and before writeState.compareAndSet()
+
   @Nullable
   private volatile Thread parkingThread;
 
@@ -209,6 +210,13 @@ private void assureReadyAndDrainedTurnsFalse() {
     parkingThread = null;
   }
 
+  private void markNotReadyAndUnpark(WriteState curState) {
+    boolean successful = writeState.compareAndSet(curState, curState.withReadyAndDrained(false));
+    checkState(successful, "Bug: curState is unexpectedly changed by another thread");
+    LockSupport.unpark(parkingThread);
+    log.finest("the servlet output stream becomes not ready");
+  }
+
   /**
    * Either execute the write action directly, or buffer the action and let the container thread
    * drain it.
@@ -217,30 +225,38 @@ private void assureReadyAndDrainedTurnsFalse() {
    */
   private void runOrBuffer(ActionItem actionItem) throws IOException {
     WriteState curState = writeState.get();
-    if (curState.readyAndDrained) { // write to the outputStream directly
+
+    // Tomcat Spontaneous State Change Mitigation ---
+    // If our cache says true, but the container is secretly not ready,
+    // intercept the stale state and sync it before proceeding.
+    if (curState.readyAndDrained && !isReady.getAsBoolean()) {
+      markNotReadyAndUnpark(curState);
+      // Update local state so it gracefully bypasses the 
+      // direct write and falls into the buffer block
+      curState = writeState.get(); 
+    }
+    // -------------------------------------------------------    
+    if (curState.readyAndDrained) {
       actionItem.run();
       if (actionItem == completeAction) {
         return;
       }
       if (!isReady.getAsBoolean()) {
-        boolean successful =
-            writeState.compareAndSet(curState, curState.withReadyAndDrained(false));
-        LockSupport.unpark(parkingThread);
-        checkState(successful, "Bug: curState is unexpectedly changed by another thread");
-        log.finest("the servlet output stream becomes not ready");
+        markNotReadyAndUnpark(curState);
+      }
+      return;
+    }
+
+    writeChain.offer(actionItem);
+    if (!writeState.compareAndSet(curState, curState.withReadyAndDrained(false))) {
+      checkState(
+          writeState.get().readyAndDrained,
+          "Bug: onWritePossible() should have changed readyAndDrained to true, but not");
+      ActionItem lastItem = writeChain.poll();
+      if (lastItem != null) {
+        checkState(lastItem == actionItem, "Bug: lastItem != actionItem");
+        runOrBuffer(lastItem);
       }
-    } else { // buffer to the writeChain
-      writeChain.offer(actionItem);
-      if (!writeState.compareAndSet(curState, curState.withReadyAndDrained(false))) {
-        checkState(
-            writeState.get().readyAndDrained,
-            "Bug: onWritePossible() should have changed readyAndDrained to true, but not");
-        ActionItem lastItem = writeChain.poll();
-        if (lastItem != null) {
-          checkState(lastItem == actionItem, "Bug: lastItem != actionItem");
-          runOrBuffer(lastItem);
-        }
-      } // state has not changed since
     }
   }