feat(api): add Engine.SetNoRoute(h) for late-binding the SPA handler

WithNoRoute(h) at construction covers most cases, but SPA hosts
often resolve their frontend FS (via embed.FS sub or fs.Sub) AFTER
the Engine is constructed — e.g. lthn/desktop builds pkg/server
first, then pkg/desktop reads its embedded dist/ and attaches the
fallback. SetNoRoute lets the handler land late.

Mirrors the existing late-binding pattern for groups (Engine.Register).
TestSetNoRoute_Good_AttachesAfterConstruction covers the canonical
late-bind flow.

Author: Snider

go/api.go

@@ -289,6 +289,22 @@ func (e *Engine) Serve(ctx context.Context) (
 	return <-errCh
 }
 
+// SetNoRoute attaches or replaces the fallback handler invoked when
+// no registered route matches the incoming request. Mirrors the
+// WithNoRoute Option but is callable after construction — useful
+// when the SPA handler is built later in the boot sequence than
+// the Engine (e.g. once the embedded frontend FS is resolved).
+// Pass nil to clear and restore gin's default 404.
+//
+// Example:
+//
+//	e, _ := api.New()
+//	// … later, once dist/ is mounted …
+//	e.SetNoRoute(spaHandler)
+func (e *Engine) SetNoRoute(h gin.HandlerFunc) {
+	e.noRouteHandler = h
+}
+
 // build creates a configured Gin engine with recovery middleware,
 // user-supplied middleware, the health endpoint, and all registered route groups.
 func (e *Engine) build() *gin.Engine {

go/no_route_test.go

@@ -60,6 +60,34 @@ func TestWithNoRoute_Bad_DoesNotShadowExplicitRoutes(t *testing.T) {
 	}
 }
 
+// TestSetNoRoute_Good_AttachesAfterConstruction verifies late binding —
+// SetNoRoute mirrors WithNoRoute but is callable after New() returns.
+// Pattern: SPA host knows its frontend FS only after the asset embed
+// resolves, which can land later than the Engine's construction.
+func TestSetNoRoute_Good_AttachesAfterConstruction(t *testing.T) {
+	const payload = "LATE-BOUND-SPA"
+
+	e, err := New() // no WithNoRoute at construction time
+	if err != nil {
+		t.Fatalf("api.New: %v", err)
+	}
+
+	e.SetNoRoute(func(c *gin.Context) {
+		c.String(http.StatusOK, payload)
+	})
+
+	w := httptest.NewRecorder()
+	req := httptest.NewRequest(http.MethodGet, "/some/spa/route", nil)
+	e.Handler().ServeHTTP(w, req)
+
+	if w.Code != http.StatusOK {
+		t.Fatalf("status = %d, want 200", w.Code)
+	}
+	if got := w.Body.String(); got != payload {
+		t.Fatalf("body = %q, want %q", got, payload)
+	}
+}
+
 // TestWithNoRoute_Ugly_NilStaysAsDefault404 verifies the degenerate path —
 // no NoRoute set means gin's default 404 surfaces unchanged. This protects
 // the contract that WithNoRoute is opt-in and unset Engines stay