Implement find() wait and RECONNECT structure event

find() now waits for the target app to appear instead of failing
immediately. subscribeToStructure fires RECONNECT (2) when an app
reappears after being removed, distinguishing restarts from first-time
appearances.

Changes:
- find() waits indefinitely by default; { timeout: N } limits the wait;
  { timeout: 0 } preserves the old immediate-fail behavior
- find() works without prior root() call (triggers connection internally)
- close() is terminal: sets isClosed flag, rejects pending find() waiters,
  prevents reconnection after close
- RECONNECT constant (2) added alongside ADD (1) and REMOVE (0)
- Per-app lifecycle via announceApp/unannounceApp: each app is tracked
  independently, fixing the bug where one sibling disconnecting lost
  all sibling connections
- Subscription keepalive via inactivityResendInterval field (client
  requests server resend values/events after 120s of no changes,
  matching C++ client ServicesProtocol::InactivityResendIntervalSec)
- Value dedup via lastServerTimestamp and event dedup via recentEventIds
  to handle server replay after reconnection
- Exponential backoff with jitter for reconnection (1s to 30s max)
- Stall detection: force reconnect after 150s of server silence with
  active subscriptions (must exceed 120s keepalive interval)
- Direct mode sibling discovery uses server-pushed
  eStructureChangeResponse instead of client-side polling
- CDP_FORCE_DIRECT_MODE=1 env var to force direct mode on proxy-capable
  servers (for testing)
- Cache key fix: use join('.') instead of toString() for correct
  invalidateApp prefix matching on app structure changes
- Remove unused serviceId storage on proxy connections
- Fix instanceId serialization: pass through as-is instead of defaulting
  falsy values to 0
- appAddress() helper for DRY server address construction
- README updated with Structure Events section and find() options
- Version bump to 3.0.0 (breaking: find() default changed from
  immediate fail to indefinite wait)

CDP-6069

Author: stefanrammo

README.rst

@@ -38,6 +38,8 @@ Example
           root.subscribeToStructure((name, change) => {
             if (change === studio.api.structure.ADD)
               subscribeToApp(name);
+            if (change === studio.api.structure.RECONNECT)
+              console.log(`${name} restarted, subscriptions intact`);
           });
         }).catch(err => console.error("Connection failed:", err));
 
@@ -61,6 +63,41 @@ Benefits
 - Simplified firewall configuration - only one port needs to be opened
 - SSH port forwarding - forward a single port to access entire CDP system
 
+Structure Events
+----------------
+
+On the root node, ``subscribeToStructure`` tracks application lifecycle with three event types:
+
+- ``studio.api.structure.ADD`` (1) — An application appeared for the first time
+- ``studio.api.structure.REMOVE`` (0) — An application went offline
+- ``studio.api.structure.RECONNECT`` (2) — An application restarted (was seen before, went offline, came back)
+
+On other nodes, ADD and REMOVE fire when children are added or removed at runtime.
+RECONNECT only fires at the root level.
+
+When an app restarts, the client automatically restores value and event subscriptions,
+so user code does not need to re-subscribe. RECONNECT is informational — use it for
+logging or UI updates.
+
+    .. code:: javascript
+
+        client.root().then(root => {
+          root.subscribeToStructure((appName, change) => {
+            if (change === studio.api.structure.ADD) {
+              console.log(`New app online: ${appName}`);
+              client.find(appName + '.CPULoad').then(node => {
+                node.subscribeToValues(v => console.log(`[${appName}] CPULoad: ${v}`));
+              }).catch(err => console.error(`Failed to find ${appName}.CPULoad:`, err));
+            }
+            if (change === studio.api.structure.REMOVE) {
+              console.log(`App offline: ${appName}`);
+            }
+            if (change === studio.api.structure.RECONNECT) {
+              console.log(`App restarted: ${appName}, subscriptions intact`);
+            }
+          });
+        }).catch(err => console.error("Connection failed:", err));
+
 API
 ---
 
@@ -325,31 +362,46 @@ client.root()
           // use the system INode object to access connected structure.
         });
 
-client.find(path)
-^^^^^^^^^^^^^^^^^
+client.find(path, options)
+^^^^^^^^^^^^^^^^^^^^^^^^^
 
 - Arguments
 
-    path - Path of the object to look for.
+    path - Dot-separated path to target node (e.g. ``'App2.CPULoad'``).
+
+    options - Optional. Without this, find() waits indefinitely for the app to appear.
+    ``{ timeout: milliseconds }`` to limit wait time.
+    ``{ timeout: 0 }`` to fail immediately if the app is not available.
 
 - Returns
 
     Promise containing requested INode object when fulfilled.
 
-- Restriction
+- Behavior
 
-    The requested node must reside in the application client was connected to.
+    When no timeout option is provided, waits indefinitely for the target application to appear.
+    If the application is already available, resolves immediately. No prior ``root()`` call is needed — ``find()`` triggers
+    the connection internally.
 
-- Usage
+- Examples
 
-    The provided path must contain dot separated path to target node. **Root node is not considered part of the path.**
+    .. code:: javascript
 
-- Example
+        // Waits indefinitely for App2 to appear
+        client.find("App2.CPULoad").then(function (load) {
+          load.subscribeToValues(function (value) {
+            console.log("CPULoad:", value);
+          });
+        });
 
-    .. code:: javascript
+        // Wait up to 5 seconds
+        client.find("App2.CPULoad", { timeout: 5000 }).catch(function (err) {
+          console.log(err.message); // "App2 not found within 5000ms"
+        });
 
-        client.find("MyApp.CPULoad").then(function (load) {
-          // use the load object referring to CPULoad in MyApp
+        // Fail immediately if not available (old behavior)
+        client.find("App2.CPULoad", { timeout: 0 }).catch(function (err) {
+          console.log("Not available right now");
         });
 
 client.close()
@@ -604,8 +656,9 @@ node.subscribeToStructure(structureConsumer)
 
 - Usage
 
-    Subscribe to structure changes on this node. Each time child is added or removed from current node
-    structureConsumer function is called with the name of the node and change argument where ADD == 1 and REMOVE == 0.
+    Subscribe to structure changes on this node. Each time a child is added or removed,
+    structureConsumer is called with the child name and change (ADD == 1, REMOVE == 0).
+    On the root node, RECONNECT (2) fires when a previously-seen application restarts.
 
 node.unsubscribeFromStructure(structureConsumer)
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^