feat: add cross-platform NativeWindow implementation - #11181

…ling

- Refactored NativeWindow to separate platform-specific implementations for Android and iOS.
- Introduced AndroidNativeWindow and IOSNativeWindow classes extending a common NativeWindow base class.
- Updated lifecycle event notifications to emit events directly from NativeWindow instances instead of the Application class.
- Deprecated direct event listeners on the Application class in favor of listening on NativeWindow instances.
- Removed redundant index files for native-window on both Android and iOS platforms.
- Enhanced type definitions for NativeWindow events and interfaces to improve clarity and maintainability.

…heir payloads

The activity*/scene* events on Application are aggregate APIs that fire for
every window; args.window identifies which one. SceneEventData's native
UIWindow moves to uiWindow so that a 'window' payload key always means a
NativeWindow.

…ming collisions

WindowBase carries identity, role, state, lifecycle events and the native
accessors; NativeWindow adds the view-carrying half. Surfaces without a
NativeScript view tree (CarPlay, external displays) can extend WindowBase.

BREAKING CHANGE: NativeWindow.iosWindow is now .ios and its window property
is .uiWindow; NativeWindow.androidWindow is now .android. getWindows() is
role-filtered and defaults to application and embedded windows.

…exit rewire

A window now survives its native surface going away: iOS keys identity off
UISceneSession.persistentIdentifier, Android mints a UUID persisted in
savedInstanceState. A scene disconnect or an activity recreation detaches the
window - it stays registered and keeps its listeners - while a real close ends
the session, fires 'close' exactly once and then clears the instance listeners.

Android 'exit' now fires when the last window goes away rather than for any
finishing activity; iOS 'exit' remains process termination.

…nership inversion)

Every iOS app now registers at least one window - scene, non-scene and
embedded alike - and all content flows through NativeWindow.setContent().
The app-level root view state (getRootView(), the global root view and the
initRootView event) mirrors whatever the primary window shows.

Embedded windows hand their controller to the embedder delegate and never
touch rootViewController or makeKeyAndVisible: the host app owns the window.

resetActivityContent() accepts an explicit view, so NativeWindow.setContent()
no longer has its argument discarded and rebuilt from the main entry.

Root views built by the activity pipeline are handed to their window through
_adoptRootView(), which records the view and fires contentLoaded without
redoing the setup the pipeline already performed. Embedded hosts get a window
with role 'embedded'.

…cation

'launch' conflated process initialization with building the first window's UI,
which cannot work for additional windows or for background launches. 'ready'
now covers initialization - fired exactly once per JS context, never deferred,
always before the first windowOpen - while setWindowContentResolver() supplies
each window's UI on demand.

'launch' keeps working as a bridge for the first view-carrying window,
including its 'root' three-state contract. shouldDelayLaunchEvent is a
deprecated no-op.

…tions in scene mode

App-level suspend/resume were driven by the primary scene, so a multi-scene app
reported itself suspended while other scenes were still on screen. They now
follow UIApplication's own foreground/background notifications, which describe
the whole app. Per-window state stays available through NativeWindow events.

…m openWindow (Android experimental)

The registry, its events and primary promotion had one copy per platform; they
now live on ApplicationCommon, with protected hooks for the iOS-specific
bookkeeping. openWindow() takes WindowOpenOptions on both platforms.

Android openWindow() launches a real second activity. It is experimental:
whether a new window appears depends on the manifest launchMode and on OEM
recents behavior.

Orientation, system appearance and layout direction are per-window: each
NativeWindow reads them live from its own surface, raises its own changed
events, and scopes its CSS classes to its own root view and that root's modals
instead of the process-wide system class list. Application-level getters and
events continue to reflect the primary window.

Accessibility CSS is applied per root view, so windows beyond the first are no
longer skipped.

…ttern

Adds a curated public surface for native-window - WindowBase, NativeWindow,
the event constants and payload types, the resolver types - keeping internals
and the concrete platform classes out of the published typings.

Also brings application.d.ts back in line with the implementation: the platform
classes declared on() as method overloads, which hid ApplicationCommon's own
handler surface, and several referenced types were never imported and silently
resolved to any.

Covers the window lifecycle contract (attach/detach/re-attach/close, close
firing once, listeners cleared only after close and surviving a detach), the
registry's role filtering and primary promotion, the content resolution chain
including the launch bridge's three-state root and app CSS loading on every
path, and the Android trait converters and session-id round trip.

Rewrites the multiple-scenes page on the shared window API: windows are opened
with Application.openWindow({ data }), their UI comes from a
setWindowContentResolver, and each row shows live id/role/state/traits driven
by that window's own events. Gating is by capability rather than platform, so
the page renders and explains itself on Android too.

…none remain

unregisterBroadcastReceiver empties the entry rather than deleting it, so the
optional chain guarded the array but not its first element and the getter threw
for a filter that had been registered and then unregistered.

…hods

Once an app adopts scenes, UIKit stops calling applicationOpenURLOptions,
applicationContinueUserActivityRestorationHandler and
applicationPerformActionForShortcutItemCompletionHandler and delivers them to
the scene delegate instead, so handlers registered through addDelegateHandler()
stopped firing - deep links, universal links, Handoff and quick actions.

The scene delegate now implements all three, raising a per-window event and its
Application-level bridge, then forwarding to the legacy delegate method so
existing handlers keep working. A quick action's completion handler is shared
between listeners and the legacy handler and reports at most once.

…window adopts it

Views had no supported route back to the window showing them. getNativeWindow()
walks up to the root view - through the presenting view of any modal - and
reads the window that owns it, resolving on every call so a view re-parented
into another tree reports where it moved to.

iOS lets a UIView change windows, and setContent() only ever reset its own
previous root, so two windows could claim the same root view and UIKit could be
left holding a rootViewController it no longer hosts. A window now releases its
root when another adopts it, without tearing the view down.

Reading the activity callbacks key pulled native-window.android into
ui/frame/frame-helper-for-android, which reaches back through
fragment.transitions.android to application.android. The key and the frame id
now live in a module of their own with no imports, so both sides can read them
without the cycle.

The frame-common import alongside it was types only and is now an import type;
NavigationEntry there was unused.

Both back paths resolved the pressing activity's own root view and then handed
navigation to Frame.goBack(), which walks the process-global frame stack - so
with two windows a back press in one window could navigate the other, whichever
had navigated most recently.

Frame.goBack() now takes an optional frame to go back from, defaulting to the
topmost as before, and the Android back paths pass the frame they already
resolved. The terminal pop is skipped for a frame that is not at the top of the
stack, which would otherwise throw.

The frame stack is process-global and a frame reaches its top on navigate, so
with more than one window Frame.topmost() returned whichever frame navigated
most recently anywhere - sending dialogs, keyboard dismissal and back
delegation to the wrong window.

Frame.topmost() now takes an optional window and defaults to the newly exposed
Application.activeWindow. A frame that belongs to no window still wins outright,
so single-window behaviour is unchanged in every arrangement.