fix(cdp): five Playwright drop-in compatibility patches

Brings Obscura's CDP server in line with what Playwright's
`chromium.connectOverCDP()` expects. Each fix is small and surgical;
together they make `connect → newContext → newPage → goto → page.title()`
work end-to-end against `https://example.com`.

1. **server.rs — emit pending events before command response.**
   Chromium CDP semantics require side-effect events (e.g.
   `Target.targetCreated` + `Target.attachedToTarget` from
   `Target.createTarget`) to arrive *before* the originating command's
   response. Playwright's wire reader assumes this ordering — it
   resolves the response promise on the response and then synchronously
   looks up the freshly-created session. Reversing the order makes that
   lookup miss and the page hang at `newPage()`.

2. **domains/browser.rs — accept Browser.setWindowBounds as a no-op.**
   Playwright calls `Browser.setWindowBounds` during teardown. Returning
   "Unknown Browser method" causes Playwright to treat the target as
   broken and tear it down mid-test, surfacing as "Frame has been
   detached" on the next `page.title()`.

3. **obscura-browser/page.rs — frame_id == target_id for main frame.**
   Was `format!("{id}.1", id)`. Playwright's frame manager indexes
   frames by frame id and looks up the main frame by target id, so the
   `.1` suffix made every main-frame lookup miss.

4. **domains/page.rs + dispatch.rs — track isolated worlds and re-emit
   them post-navigation.** Playwright registers a utility world via
   `Page.createIsolatedWorld` and expects `Runtime.executionContextCreated`
   for each registered world after every navigation. Without re-emission,
   the utility-world handle goes stale post-`goto` and `page.title()`
   hangs waiting for the world's execution context. Falls back to the
   legacy `__puppeteer_utility_world__24.40.0` name when no worlds have
   been registered, preserving prior Puppeteer support.

5. **obscura-js/runtime.rs — strip trailing semicolons before wrapping.**
   Playwright's utility-script expression is an IIFE ending in `})();`.
   Both `wrap_expression` (CDP `Runtime.evaluate`) and `evaluate_for_cdp`
   (the `meta_code` IIFE) embed the user expression inside `({EXPR})` /
   `return ({EXPR});`. With the trailing `;` left in, this produces
   `({...;})` — a SyntaxError. Parse errors are not catchable, so the
   surrounding try/catch never fires and the call silently returns
   `undefined`, surfacing as `page.title() === ""`.

Verified end-to-end against `https://example.com`:
  [probe] connect OK
  [probe] newContext OK
  [probe] newPage OK
  [probe] goto OK
  [probe] title = Example Domain

crates/obscura-js/src/runtime.rs

@@ -127,6 +127,13 @@ impl ObscuraJsRuntime {
         self.object_counter += 1;
         let oid = self.make_oid(self.object_counter);
 
+        // Same trailing-semicolon trim as wrap_expression — Playwright's
+        // utility-script eval ends with `})();`, and `({expr})` would
+        // otherwise become `(...;)` which is a parse-time SyntaxError.
+        let cleaned_expr = expression
+            .trim()
+            .trim_end_matches(|c: char| c == ';' || c.is_whitespace());
+
         let meta_code = format!(
             "(function() {{\n\
                 var __result;\n\
@@ -134,7 +141,7 @@ impl ObscuraJsRuntime {
                 globalThis.__obscura_objects['{oid}'] = __result;\n\
                 return {meta_fn};\n\
             }})()",
-            expr = expression,
+            expr = cleaned_expr,
             oid = oid,
             meta_fn = Self::meta_extract_js("__result"),
         );
@@ -559,9 +566,17 @@ impl ObscuraJsRuntime {
                 expression
             )
         } else {
+            // Strip trailing semicolons + whitespace before wrapping in
+            // `return (...);`. Playwright's utility-script expression is
+            // an IIFE that ends with `})();` — leaving the `;` in place
+            // produces `return (...;);`, a SyntaxError. The script fails
+            // to parse, the catch never fires (parse errors are not
+            // catchable), and the function silently returns `undefined`.
+            // Stripping makes the wrapped expression syntactically valid.
+            let cleaned = trimmed.trim_end_matches(|c: char| c == ';' || c.is_whitespace());
             format!(
                 "(function() {{ try {{ return ({}); }} catch(e) {{ return null; }} }})()",
-                expression
+                cleaned
             )
         }
     }