Fix Stage 3 decorator inheritance (mobxjs#4661)

* fix: @computed override with super no longer causes cycle detection

Fixes mobxjs#4639 — when a child class @computed getter references super.value,
MobX no longer throws 'Cycle detected in computation'.

Architecture:
- Common case (no inheritance): factories stored in lazyComputedKeys_
  (identical to main branch), materialized on first read
- Inheritance case: parent entries moved to computedGetterEntries_ (Map
  keyed by getter function), child entries in computedEntries_
- readComputed_ method checks derivation === expectedGet to detect
  super calls and routes to the correct ComputedValue
- Prototype chain traversal + __mobx_get finds parent getter without
  per-instance WeakMap overhead
- getObservablePropValue_ kept clean (no expectedGet) for makeObservable

Performance vs main branch (50k instances × 10 computed getters):
  Heap:        +0.5%
  Construct:   -7.8%
  First-read:  -4.2%
  Re-read:     +6.6% (inherent cost of derivation check for super support)

* Revert "fix: @computed override with super no longer causes cycle detection"

This reverts commit a559575.

* Fix Stage 3 computed inheritance

* Simplify inheritance tests

* Document unsupported (for now) test

* Reorg tests

---------

Co-authored-by: Gorbachev Egor <7gorbachevm@gmail.com>
Co-authored-by: Сергей Волков <ser.volkov@vk.team>

Author: 3 people

.changeset/fresh-computed-super.md

@@ -0,0 +1,5 @@
+---
+"mobx": patch
+---
+
+Fix Stage 3 `@computed` overrides that delegate to a same-named parent getter via `super`.

docs/subclassing.md

@@ -8,10 +8,13 @@ hide_title: true
 
 # Subclassing
 
-Subclassing is supported with [limitations](#limitations). Most notably you can only **override actions/flows/computeds on prototype** - you cannot override _[field declarations](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes#field_declarations)_. Use the `override` annotation for methods/getters overridden in a subclass - see example below. Try to keep things simple and prefer composition over inheritance.
+Subclassing is supported with [limitations](#limitations). Most notably you can only **override actions/flows/computeds on prototype** - you cannot override _[field declarations](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes#field_declarations)_. When using `makeObservable`, use the `override` annotation for methods/getters overridden in a subclass. When using modern decorators, redecorate the overridden prototype method/getter in the subclass. Try to keep things simple and prefer composition over inheritance.
+
+<!--DOCUSAURUS_CODE_TABS-->
+<!--makeObservable-->
 
 ```javascript
-import { makeObservable, observable, computed, action, override } from "mobx"
+import { makeObservable, observable, computed, action, flow, override } from "mobx"
 
 class Parent {
     // Annotated instance fields are NOT overridable
@@ -25,14 +28,16 @@ class Parent {
     action() {}
     actionBound() {}
     get computed() {}
+    *flow() {}
 
     constructor(value) {
         makeObservable(this, {
             observable: observable,
-            arrowAction: action
+            arrowAction: action,
             action: action,
             actionBound: action.bound,
             computed: computed,
+            flow: flow
         })
     }
 }
@@ -50,13 +55,15 @@ class Child extends Parent {
     action() {}
     actionBound() {}
     get computed() {}
+    *flow() {}
 
     /* --- NEW --- */
-    childObservable = 0;
+    childObservable = 0
     childArrowAction = () => {}
     childAction() {}
     childActionBound() {}
     get childComputed() {}
+    *childFlow() {}
 
     constructor(value) {
         super()
@@ -65,17 +72,73 @@ class Child extends Parent {
             action: override,
             actionBound: override,
             computed: override,
+            flow: override,
             // new
             childObservable: observable,
             childArrowAction: action,
             childAction: action,
             childActionBound: action.bound,
             childComputed: computed,
+            childFlow: flow
         })
     }
 }
 ```
 
+<!--Modern decorators-->
+
+```javascript
+import { observable, computed, action, flow } from "mobx"
+
+class Parent {
+    // Observable state fields are inherited, but should not be re-annotated
+    // or overridden by subclasses.
+    @observable accessor observable = 0
+
+    // Decorated instance fields should not be re-annotated or overridden.
+    @action arrowAction = () => {}
+
+    // Non-decorated instance fields are overridable.
+    overridableArrowAction = action(() => {})
+
+    // Decorated prototype methods/getters are overridable.
+    @action action() {}
+    @action.bound actionBound() {}
+    @computed get computed() {}
+    @flow *flow() {}
+}
+
+class Child extends Parent {
+    /* --- INHERITED --- */
+    // Unsupported: do not re-annotate or override observable/accessor fields.
+    // @observable accessor observable = 5
+    // @action arrowAction = () => {}
+
+    // OK - not decorated
+    overridableArrowAction = action(() => {})
+
+    // OK - prototype
+    @action action() {}
+    @action.bound actionBound() {}
+    @computed get computed() {
+        return super.computed
+    }
+    @flow *flow() {
+        return yield super.flow()
+    }
+
+    /* --- NEW --- */
+    @observable accessor childObservable = 0
+    @action childArrowAction = () => {}
+    @action childAction() {}
+    @action.bound childActionBound() {}
+    @computed get childComputed() {}
+    @flow *childFlow() {}
+}
+```
+
+<!--END_DOCUSAURUS_CODE_TABS-->
+
 ## Limitations
 
 1. Only `action`, `computed`, `flow`, `action.bound` defined **on prototype** can be **overridden** by subclass.