feat: invoke page level JavaScript through a JS invoker - #25799

Depends on #25749
Part of #10759
Part of #25734

missing API · flow-server, flow-client · applications that want a
strict content security policy for page level JavaScript

Background — JS invokers. #25749 adds interfaces that declare the
JavaScript the server can invoke as @JsExpression constants, collected
into the bundle by the build. An invocation then names the interface and
the method instead of carrying a script, so nothing is compiled in the
browser and the call works without unsafe-eval.

That covers the element level entry point. This adds the page level one,
so Page declares its JavaScript the same way Element does.

@JsInvoker
public interface ClipboardJs extends Serializable {
    @JsExpression("return navigator.clipboard.readText()")
    PendingJavaScriptResult readText();
}

page.getJsInvoker(ClipboardJs.class).readText().then(String.class, text -> ...);

Risks:

• ⚠️ Public API: Page.getJsInvoker(Class), and JsInvokers as the
  factory both entry points hand out invokers through.
• ⚠️ Protocol: the target of an invoker invocation says whether the
  parameter after the arguments is the element to apply the function to.
  Server and client change together.
• ❓ Open question: a page invoker method runs with no this, where
  Page.executeJs runs its expression against the context object. That
  keeps the framework's plumbing out of declared JavaScript, which works
  on globals instead.
• ✅ No change to what an element invoker sends, to threading or to
  performance.

Context. The types the declarations use are already neutral between
the two entry points; what was missing was the page level way in, and a
way for the client to know that a call has no element behind it.

• Page.getJsInvoker(Class) schedules the way Page.executeJs does, so
  an invoker call and an expression reach the client in the order they
  were made.
• Both page paths now build their invocation and hand it to one place
  that owns it with the root node.
• JsInvokers creates the invoker for both entry points, so what a
  method may return and which interfaces are usable are the same
  wherever an invoker came from.
• The client reads the element only when the target has one, and runs a
  function with no this when it does not.