Looks good on the whole, but it's worth pointing out that the role of disposability as stated here – basically a "sweeper" that avoids having to manually perform any last-ditch teardown (such as would occur in a finally block), but which still puts the onus on the user to explicitly invoke graceful disposal under normal execution – doesn't tally with the indicative cases from the tc39 proposal, which imply an environment wherein one doesn't need to explicitly close one's own disposable resources at all, and can just defer to the ERM disposer under both normal and abnormal conditions.

I don't have any strong feelings here, but probably warrants discussion.

Unless I missed it, this document doesn't really cover creating handles like in #58453, i.e. these:

  return {
    [SymbolDispose]: () => this.removeListener(type, listener),
  };

Since we don't have using void yet and disposables are not always grouped by DisposableStacks, these objects usually will be exposed in userspace and have some user-defined names.
Should such objects be just this? Maybe they should be instances of some DisposableEntity class, implementing disposable interface? Or maybe they should be null-prototyped? Or maybe they should have Symbol.toPrimitive or kInspect that would help identifying what this object is? Or we should also add non-symbol dispose function (if so, we probably should come up with a generic name for all such objects)?

This document is very informative. Excited to see more of this implemented throughout core

lgtm but you might want to consider changing the setTimeout examples.

A few final copyedits and minor suggestions.

Looks good in general, certainly as a base to iterate on with experience. I do think that attempting graceful disposal in a could-have-errored context isn't necessarily as scary as these guidelines currently make out, but I imagine that more familiarity will lend a better sense of which paradigm is more useful.

Minor stuff

After rereading the whole thing, a few more suggestions below.

Additionally, I think this document should cover two more things:

1. According to the description of the Disposable Interface, ERM disposer should return undefined, and async disposer should return a Promise that resolves with undefined. So, roughly speaking,

[SymbolDispose]() {
-  return this.dispose();
-  return this;
-  return this.#statusCode;
-  return true;
+  return void this.dispose();
+  this.dispose();
+  return;
+  // no return
}

2. To improve debugging experience, [Symbol.dispose] function must not be a direct alias of named disposer function. This way, it would be possible to actually tell from stack traces if we're dealing with using or conventional method.

- MyObject.prototype[SymbolDispose] = MyObject.prototype.dispose;
- MyObject.prototype[SymbolDispose] = MyObjectDisposeImpl;
- MyObject.prototype[SymbolDispose] = function dispose() { this.close(); }

+ MyObject.prototype[SymbolDispose] = assignFunctionName(SymbolDispose, function() {
+   this.idempotentDispose();
+ });

LGTM with suppressing the linter