Docs: Convert JavaScript guide to use only namespaced syntax

Updates JavaScript programming documentation to use only namespaced
syntax (inav.flight.*, inav.override.*, etc.) instead of destructuring.

Preserves all new INAV 9.0 features:
- PID controller output access (inav.pid[0-3].output)
- Flight mode detection (inav.flight.mode.poshold, etc.)
- Let/const variables for compile-time named expressions
- Ternary operator support

Changes:
- Remove all destructuring syntax (const { flight, override } = inav)
- Convert all examples to use fully-qualified namespaced access
- Simplify sticky() documentation to show only callback syntax
- Update event functions to use inav.events.* namespace

This provides clearer, more explicit code examples that make it
obvious where each identifier comes from.

Author: sensei-hacker

docs/javascript_programming/JAVASCRIPT_PROGRAMMING_GUIDE.md

@@ -22,11 +22,9 @@ conditions behind the scenes.
 Use `if` statements for conditions that should check and execute **every cycle**:
 
 ```javascript
-const { flight, override } = inav;
-
 // Checks every cycle - adjusts VTX power continuously
-if (flight.homeDistance > 100) {
-  override.vtx.power = 3;
+if (inav.flight.homeDistance > 100) {
+  inav.override.vtx.power = 3;
 }
 ```
 
@@ -38,12 +36,10 @@ if (flight.homeDistance > 100) {
 Use `edge()` for actions that should execute **only once** when a condition becomes true:
 
 ```javascript
-const { flight, gvar, edge } = inav;
-
 // Executes ONCE when armTimer reaches 1000ms
-edge(() => flight.armTimer > 1000, { duration: 0 }, () => {
-  gvar[0] = flight.yaw;  // Save initial heading
-  gvar[1] = 0;           // Initialize counter
+inav.events.edge(() => inav.flight.armTimer > 1000, { duration: 0 }, () => {
+  inav.gvar[0] = inav.flight.yaw;  // Save initial heading
+  inav.gvar[1] = 0;                // Initialize counter
 });
 ```
 
@@ -61,45 +57,20 @@ edge(() => flight.armTimer > 1000, { duration: 0 }, () => {
 ---
 
 ### Latching/Sticky Conditions
-Use `sticky()` for conditions that latch ON and stay ON until reset.
-
-**Option 1: Variable assignment syntax** (recommended when you need to reference the latch state):
+Use `sticky()` for conditions that latch ON and stay ON until reset:
 
 ```javascript
-const { flight, gvar, sticky, override } = inav;
-
-// Create a latch: ON when RSSI < 30, OFF when RSSI > 70
-var rssiWarning = sticky({
-  on: () => flight.rssi < 30,
-  off: () => flight.rssi > 70
-});
-
-// Use the latch to control actions
-if (rssiWarning) {
-  override.vtx.power = 4;  // Max power while latched
-}
-```
-
-**Option 2: Callback syntax** (simpler when actions are self-contained):
-
-```javascript
-const { flight, sticky, override } = inav;
-
 // Latch ON when RSSI < 30, OFF when RSSI > 70
-sticky(
-  () => flight.rssi < 30,  // ON condition
-  () => flight.rssi > 70,  // OFF condition
+inav.events.sticky(
+  () => inav.flight.rssi < 30,  // ON condition
+  () => inav.flight.rssi > 70,  // OFF condition
   () => {
-    override.vtx.power = 4;  // Executes while latched
+    inav.override.vtx.power = 4;  // Executes while latched
   }
 );
 ```
 
-**Parameters (variable syntax):**
-- **on**: Condition that latches ON
-- **off**: Condition that latches OFF
-
-**Parameters (callback syntax):**
+**Parameters:**
 - **onCondition**: When to latch ON
 - **offCondition**: When to latch OFF
 - **action**: What to do while latched
@@ -115,11 +86,9 @@ sticky(
 Use `delay()` to execute after a condition has been true for a duration:
 
 ```javascript
-const { flight, gvar, delay } = inav;
-
 // Executes only if RSSI < 30 for 2 seconds continuously
-delay(() => flight.rssi < 30, { duration: 2000 }, () => {
-  gvar[0] = 1;  // Set failsafe flag
+inav.events.delay(() => inav.flight.rssi < 30, { duration: 2000 }, () => {
+  inav.gvar[0] = 1;  // Set failsafe flag
 });
 ```
 
@@ -139,74 +108,63 @@ delay(() => flight.rssi < 30, { duration: 2000 }, () => {
 
 ### Initialize on Arm
 ```javascript
-const { flight, gvar, edge } = inav;
-
-edge(() => flight.armTimer > 1000, { duration: 0 }, () => {
-  gvar[0] = 0;              // Reset counter
-  gvar[1] = flight.yaw;     // Save heading
-  gvar[2] = flight.altitude; // Save starting altitude
+inav.events.edge(() => inav.flight.armTimer > 1000, { duration: 0 }, () => {
+  inav.gvar[0] = 0;                      // Reset counter
+  inav.gvar[1] = inav.flight.yaw;        // Save heading
+  inav.gvar[2] = inav.flight.altitude;   // Save starting altitude
 });
 ```
 
 ### Count Events
 ```javascript
-const { flight, gvar, edge } = inav;
-
 // Initialize
-edge(() => flight.armTimer > 1000, { duration: 0 }, () => {
-  gvar[0] = 0;
+inav.events.edge(() => inav.flight.armTimer > 1000, { duration: 0 }, () => {
+  inav.gvar[0] = 0;
 });
 
 // Count each time RSSI drops below 30 (counts transitions, not duration)
-edge(() => flight.rssi < 30, { duration: 100 }, () => {
-  gvar[0] = gvar[0] + 1;
+inav.events.edge(() => inav.flight.rssi < 30, { duration: 100 }, () => {
+  inav.gvar[0] = inav.gvar[0] + 1;
 });
 ```
 
 ### Debounce Noisy Signals
 ```javascript
-const { flight, override, edge } = inav;
-
 // Only trigger if RSSI < 30 for at least 500ms
-edge(() => flight.rssi < 30, { duration: 500 }, () => {
-  override.vtx.power = 4;
+inav.events.edge(() => inav.flight.rssi < 30, { duration: 500 }, () => {
+  inav.override.vtx.power = 4;
 });
 ```
 
 ### Multi-Stage Logic
 ```javascript
-const { flight, override } = inav;
-
 // Stage 1: Far away
-if (flight.homeDistance > 500) {
-  override.vtx.power = 4;
+if (inav.flight.homeDistance > 500) {
+  inav.override.vtx.power = 4;
 }
 
-// Stage 2: Medium distance  
-if (flight.homeDistance > 200 && flight.homeDistance <= 500) {
-  override.vtx.power = 3;
+// Stage 2: Medium distance
+if (inav.flight.homeDistance > 200 && inav.flight.homeDistance <= 500) {
+  inav.override.vtx.power = 3;
 }
 
 // Stage 3: Close to home
-if (flight.homeDistance <= 200) {
-  override.vtx.power = 2;
+if (inav.flight.homeDistance <= 200) {
+  inav.override.vtx.power = 2;
 }
 ```
 
 ### Hysteresis/Deadband
 ```javascript
-const { flight, gvar, sticky, override } = inav;
-
 // Turn ON at low voltage, turn OFF when recovered
-var lowVoltageWarning = sticky({
-  on: () => flight.cellVoltage < 330,   // Warning threshold
-  off: () => flight.cellVoltage > 350   // Recovery threshold
-});
-
-if (lowVoltageWarning) {
-  override.throttleScale = 50;   // Reduce throttle while in warning
-  gvar[0] = 1;                   // Warning flag
-}
+inav.events.sticky(
+  () => inav.flight.cellVoltage < 330,  // Warning threshold
+  () => inav.flight.cellVoltage > 350,  // Recovery threshold
+  () => {
+    inav.override.throttleScale = 50;   // Reduce throttle while in warning
+    inav.gvar[0] = 1;                   // Warning flag
+  }
+);
 ```
 
 ---
@@ -229,16 +187,14 @@ if (lowVoltageWarning) {
 Use `let` or `const` to define reusable expressions that are compiled into the logic:
 
 ```javascript
-const { flight, override } = inav;
-
 // Define reusable calculations
 let distanceThreshold = 500;
 let altitudeLimit = 100;
-let combinedCondition = flight.homeDistance > distanceThreshold && flight.altitude > altitudeLimit;
+let combinedCondition = inav.flight.homeDistance > distanceThreshold && inav.flight.altitude > altitudeLimit;
 
 // Use in conditions
 if (combinedCondition) {
-  override.vtx.power = 4;
+  inav.override.vtx.power = 4;
 }
 ```
 
@@ -247,24 +203,22 @@ if (combinedCondition) {
 - Compiler automatically optimizes duplicate expressions
 - Variables preserve their custom names through compile/decompile cycles
 
-**Important:** `let`/`const` variables are **compile-time substituted**, not runtime variables. For runtime state, use `gvar[]`.
+**Important:** `let`/`const` variables are **compile-time substituted**, not runtime variables. For runtime state, use `inav.gvar[]`.
 
 ### Ternary Operator
 
 Use ternary expressions for conditional values:
 
 ```javascript
-const { flight, override } = inav;
-
 // Assign based on condition
-let throttleLimit = flight.cellVoltage < 330 ? 25 : 50;
+let throttleLimit = inav.flight.cellVoltage < 330 ? 25 : 50;
 
-if (flight.cellVoltage < 350) {
-  override.throttleScale = throttleLimit;
+if (inav.flight.cellVoltage < 350) {
+  inav.override.throttleScale = throttleLimit;
 }
 
 // Inline in expressions
-override.vtx.power = flight.homeDistance > 500 ? 4 : 2;
+inav.override.vtx.power = inav.flight.homeDistance > 500 ? 4 : 2;
 ```
 
 **Use when:** You need conditional value assignment in a single expression.
@@ -273,33 +227,29 @@ override.vtx.power = flight.homeDistance > 500 ? 4 : 2;
 
 ## Available Objects
 
-```javascript
-const {
-  flight,      // Flight telemetry (including flight.mode.*)
-  override,    // Override flight parameters
-  rc,          // RC channels
-  gvar,        // Global variables (0-7)
-  pid,         // Programming PID outputs (pid[0-3].output)
-  waypoint,    // Waypoint navigation
-  edge,        // Edge detection
-  sticky,      // Latching conditions
-  delay        // Delayed execution
-} = inav;
-```
+The `inav` namespace provides access to all flight controller data and control functions:
+
+- `inav.flight` - Flight telemetry (including `flight.mode.*`)
+- `inav.override` - Override flight parameters
+- `inav.rc` - RC channels
+- `inav.gvar` - Global variables (0-7)
+- `inav.pid` - Programming PID outputs (`pid[0-3].output`)
+- `inav.waypoint` - Waypoint navigation
+- `inav.events.edge` - Edge detection
+- `inav.events.sticky` - Latching conditions
+- `inav.events.delay` - Delayed execution
 
 ### Flight Mode Detection
 
-Check which flight modes are currently active via `flight.mode.*`:
+Check which flight modes are currently active via `inav.flight.mode.*`:
 
 ```javascript
-const { flight, gvar, override } = inav;
-
-if (flight.mode.poshold === 1) {
-  gvar[0] = 1;  // Flag: in position hold
+if (inav.flight.mode.poshold === 1) {
+  inav.gvar[0] = 1;  // Flag: in position hold
 }
 
-if (flight.mode.rth === 1) {
-  override.vtx.power = 4;  // Max power during RTH
+if (inav.flight.mode.rth === 1) {
+  inav.override.vtx.power = 4;  // Max power during RTH
 }
 ```
 
@@ -310,23 +260,21 @@ if (flight.mode.rth === 1) {
 Read output values from the 4 programming PID controllers (configured in Programming PID tab):
 
 ```javascript
-const { pid, gvar, override } = inav;
-
-if (pid[0].output > 500) {
-  override.throttle = 1600;
+if (inav.pid[0].output > 500) {
+  inav.override.throttle = 1600;
 }
 
-gvar[0] = pid[0].output;  // Store for OSD display
+inav.gvar[0] = inav.pid[0].output;  // Store for OSD display
 ```
 
-**Available:** `pid[0].output` through `pid[3].output`
+**Available:** `inav.pid[0].output` through `inav.pid[3].output`
 
 ---
 
 ## Tips
 
-1. **Initialize variables on arm** using `edge()` with `flight.armTimer > 1000`
-2. **Use gvars for state** - they persist between logic condition evaluations
+1. **Initialize variables on arm** using `inav.events.edge()` with `inav.flight.armTimer > 1000`
+2. **Use inav.gvar for state** - they persist between logic condition evaluations
 3. **edge() duration = 0** means instant trigger on condition becoming true
 4. **edge() duration > 0** adds debounce time
 5. **if statements are continuous** - they execute every cycle
@@ -339,16 +287,14 @@ gvar[0] = pid[0].output;  // Store for OSD display
 
 Use global variables to track state:
 ```javascript
-const { flight, gvar, edge } = inav;
-
 // Debug counter
-edge(() => flight.armTimer > 1000, { duration: 0 }, () => {
-  gvar[7] = 0; // Use gvar[7] as debug counter
+inav.events.edge(() => inav.flight.armTimer > 1000, { duration: 0 }, () => {
+  inav.gvar[7] = 0; // Use gvar[7] as debug counter
 });
 
 // Increment on each event
-edge(() => flight.rssi < 30, { duration: 0 }, () => {
-  gvar[7] = gvar[7] + 1;
+inav.events.edge(() => inav.flight.rssi < 30, { duration: 0 }, () => {
+  inav.gvar[7] = inav.gvar[7] + 1;
 });
 
 // Check gvar[7] value in OSD or Configurator to see event count