fix(quic): only catch Exception, not fatal Error, on inbound rejection

Narrow the inbound rejection guard from catch(Throwable) to
catch(Exception) so fatal Errors (OutOfMemoryError, LinkageError, ...)
propagate instead of being downgraded to a routine connection close.
The library cannot distinguish a deliberate rejection from an
application bug, so logging stays at debug to avoid reintroducing noise.

Author: lucassaldanha

libp2p/src/main/kotlin/io/libp2p/transport/quic/QuicTransport.kt

@@ -137,10 +137,15 @@ class QuicTransport(
             // pipeline's channelActive, and the handshake-waiter handler has already removed itself
             // by this point, so an escaping exception would reach the Netty pipeline tail and log a
             // noisy "exceptionCaught reached tail of pipeline" warning while leaking the channel.
-            // Close the rejected connection instead, mirroring the dial paths.
+            // Close the rejected connection instead, mirroring the dial paths. Only Exception is
+            // caught — fatal Errors (OutOfMemoryError, LinkageError, ...) must propagate rather than
+            // be downgraded to a routine rejection. The library cannot tell a deliberate rejection
+            // from an application bug (the handler contract has no typed rejection), so the log stays
+            // at debug to avoid reintroducing the noise this guard removes; the application owns
+            // logging of its own connection decisions.
             try {
                 exposeConnection()
-            } catch (e: Throwable) {
+            } catch (e: Exception) {
                 logger.debug("Inbound connection rejected by handler; closing", e)
                 closeChannel()
             }

libp2p/src/test/kotlin/io/libp2p/transport/quic/QuicInboundHandshakeRoutingTest.kt

@@ -7,6 +7,7 @@ import io.mockk.mockk
 import io.netty.handler.codec.quic.QuicChannel
 import org.assertj.core.api.Assertions.assertThat
 import org.assertj.core.api.Assertions.assertThatCode
+import org.assertj.core.api.Assertions.assertThatThrownBy
 import org.junit.jupiter.api.Test
 import java.util.concurrent.CompletableFuture
 
@@ -136,4 +137,28 @@ class QuicInboundHandshakeRoutingTest {
 
         assertThat(closed).isTrue()
     }
+
+    @Test
+    fun `does not swallow a fatal Error thrown by the handler`() {
+        val transport = transport()
+        val inbound = identity()
+
+        var closed = false
+
+        // A fatal Error (OutOfMemoryError, LinkageError, ...) is NOT a routine connection rejection
+        // and must propagate rather than be silently downgraded to a closed connection. Only
+        // Exception is caught by routeInboundHandshake.
+        assertThatThrownBy {
+            transport.routeInboundHandshake(
+                remoteIdentity = inbound,
+                pending = null,
+                prepareConnection = { },
+                closeChannel = { closed = true },
+                holePunchChannel = { error("no hole punch is pending") },
+                exposeConnection = { throw OutOfMemoryError("simulated fatal error") }
+            )
+        }.isInstanceOf(OutOfMemoryError::class.java)
+
+        assertThat(closed).isFalse()
+    }
 }