Fix retry inside handleErrorWith (#50)

* Fix retry inside handleErrorWith

TxnRetryException (control-flow from scheduleRetry) was caught by
the generic handleErrorWith in the TxnHandleError compiler case,
causing `(retry).handleErrorWith(...)` to fail instead of retrying.
Re-raise TxnRetryException before falling through to the error handler.

* Fix scalafmt formatting

Author: gvonness-apolitical

src/main/scala/bengal/stm/runtime/TxnCompilerContext.scala

@@ -255,8 +255,9 @@ private[stm] trait TxnCompilerContext[F[_]] {
                                      case _ =>
                                        Async[F].pure(originalResult)
                                    }
-                  } yield (finalResult._1, finalResult._2)).handleErrorWith { ex =>
-                    s.raiseError(ex).map((_, ().asInstanceOf[V]))
+                  } yield (finalResult._1, finalResult._2)).handleErrorWith {
+                    case ex: TxnRetryException => Async[F].raiseError(ex)
+                    case ex => s.raiseError(ex).map((_, ().asInstanceOf[V]))
                   }
                 }
               case _ =>

src/test/scala/runtime/TxnCompilerContextSpec.scala

@@ -210,6 +210,39 @@ class TxnCompilerContextSpec extends AsyncFreeSpec with AsyncIOSpec with Matcher
         }
         .asserting(_ shouldBe "recovered")
     }
+
+    "retry propagates through handleErrorWith" in {
+      STM
+        .runtime[IO]
+        .flatMap { implicit stm =>
+          for {
+            tVar <- TxnVar.of(0)
+            readerFiber <- (for {
+                             v <- tVar.get
+                             _ <- STM[IO].waitFor(v > 0)
+                           } yield v)
+                             .handleErrorWith(_ => STM[IO].pure(-1))
+                             .commit
+                             .start
+            _      <- tVar.set(42).commit
+            result <- readerFiber.joinWithNever
+          } yield result
+        }
+        .asserting(_ shouldBe 42)
+    }
+
+    "handleErrorWith still recovers real errors" in {
+      STM
+        .runtime[IO]
+        .flatMap { implicit stm =>
+          STM[IO]
+            .abort(new RuntimeException("boom"))
+            .flatMap(_ => STM[IO].pure("unreachable"))
+            .handleErrorWith(_ => STM[IO].pure("recovered"))
+            .commit
+        }
+        .asserting(_ shouldBe "recovered")
+    }
   }
 
   "pure/delay transaction" - {