The "no method" error for each operator is installed as a method, so it fills up methods output

This issue was triaged from [`bugs/dan/1-error-methods`](https://github.com/Macaulay2/M2/blob/388c1ff0ce30d83751dea7bc7eac77fdc1305dd7/bugs/dan/1-error-methods), one of the 857 files removed from the pre-GitHub `bugs/` tree by [`d2c8d27826`](https://github.com/Macaulay2/M2/commit/d2c8d27826) and catalogued in [#36](https://github.com/Macaulay2/M2/issues/36). **The commentary below was written by Claude (Claude Opus 5, via Claude Code)**, not by @d-torrance, whose account posted it -- please weigh it accordingly.

The original file, verbatim (113 lines)

```text
This list would be more useful if "no method" error messages didn't have to be
installed as methods:

i3 : debug Core

i4 : formatDocumentTag \ methods symbol =

o4 = { ! Thing = Thing }
{ ! Type = Thing }
{ Thing % Thing = Thing }
{ Type % Type = Thing }
{ Thing & Thing = Thing }
{ Type & Type = Thing }
{ (*) Thing = Thing }
{ (*) Type = Thing }
{ Thing ** Thing = Thing }
{ Type ** Type = Thing }
{ * Thing = Thing }
{ Thing * Thing = Thing }
{ * Type = Thing }
{ Type * Type = Thing }
{ Thing ++ Thing = Thing }
{ Type ++ Type = Thing }
{ + Thing = Thing }
{ Thing + Thing = Thing }
{ + Type = Thing }
{ Type + Type = Thing }
{ - Thing = Thing }
{ Thing - Thing = Thing }
{ - Type = Thing }
{ Type - Type = Thing }
{ Thing .. Thing = Thing }
{ Type .. Type = Thing }
{ Thing / Thing = Thing }
{ Type / Type = Thing }
{ Thing // Thing = Thing }
{ Type // Type = Thing }
{ Thing : Thing = Thing }
{ Type : Type = Thing }
{ < Thing = Thing }
{ < Type = Thing }
{ << Thing = Thing }
{ Thing << Thing = Thing }
{ << Type = Thing }
{ Type << Type = Thing }
{ <= Thing = Thing }
{ <= Type = Thing }
{ Thing <==> Thing = Thing }
{ Type <==> Type = Thing }
{ Thing == Thing = Thing }
{ Type == Type = Thing }
{ Thing ===> Thing = Thing }
{ Type ===> Type = Thing }
{ Thing ==> Thing = Thing }
{ Type ==> Type = Thing }
{ > Thing = Thing }
{ > Type = Thing }
{ >= Thing = Thing }
{ >= Type = Thing }
{ Thing >> Thing = Thing }
{ Type >> Type = Thing }
{ ? Thing = Thing }
{ Thing ? Thing = Thing }
{ ? Type = Thing }
{ Type ? Type = Thing }
{ Thing @ Thing = Thing }
{ Type @ Type = Thing }
{ Thing @@ Thing = Thing }
{ Type @@ Type = Thing }
{ Thing \ Thing = Thing }
{ Type \ Type = Thing }
{ Thing \\ Thing = Thing }
{ Type \\ Type = Thing }
{ Thing ^** Thing = Thing }
{ Type ^** Type = Thing }
{ ^* Thing = Thing }
{ ^* Type = Thing }
{ Thing ^ Thing = Thing }
{ Type ^ Type = Thing }
{ Thing ^^ Thing = Thing }
{ Type ^^ Type = Thing }
{ _* RingFamily = Thing }
{ _* Thing = Thing }
{ _* Type = Thing }
{ ChainComplex _ ZZ = Thing }
{ ChainComplexMap _ ZZ = Thing }
{ IndexedVariableTable _ Thing = Thing }
{ MutableMatrix _ Sequence = Thing }
{ RawMutableMatrix _ Sequence = Thing }
{ Symbol _ Thing = Thing }
{ Thing _ Thing = Thing }
{ Type _ Type = Thing }
{ Thing | Thing = Thing }
{ Type | Type = Thing }
{ |- Thing = Thing }
{ Thing |- Thing = Thing }
{ |- Type = Thing }
{ Type |- Type = Thing }
{ Thing || Thing = Thing }
{ Type || Type = Thing }
{ ~ Thing = Thing }
{ ~ Type = Thing }
{ Thing and Thing = Thing }
{ Type and Type = Thing }
{ not Thing = Thing }
{ not Type = Thing }
{ Thing or Thing = Thing }
{ Type or Type = Thing }
{ Thing SPACE Thing = Thing }
{ Type SPACE Type = Thing }

o4 : VerticalList
```

### Where it stands today

Still true, and measurably worse than when the file was written: its transcript shows 102 entries;
`methods symbol =` now returns **154**, of which exactly **4** are real assignment methods
(`RawMutableMatrix _ Sequence`, `MutableMatrix _ Sequence`, `IndexedVariableTable _ Thing`,
`Symbol _ Thing`).

`robust.m2:64-130` installs a `Thing OP Thing` method per flexible operator whose entire body builds the
"no method for" message.

### One distinction the file conflates

74 of the 154 are `((op,=),Type,Type)` and `((op,=),Type)` inheritance dispatchers from
`methods.m2:567-578`. Those do real work, so "stop installing them" is not available for that group —
only for the message stubs.

### A one-line partial mitigation exists

150 of the 154 already satisfy `isUndocumented`, yet `documentableMethods` (`help.m2:143`) returns all
154: `isDocumentableMethod` asks whether each component of the key is an *exported type*, never whether
the key itself was marked undocumented — and `Thing` and `Type` are exported. Adding that test would
filter the stubs out of the listing, at the cost of a documentation-database lookup per key.

### Related

**#1331** asks for more output here, **#1604** is the inverse complaint, and **#3108** was fixed by
filtering unexported types (`10529388c6`) — which provably leaves every stub in place, since `Thing` is
exported.

_{`open` · disposition `issue` · source of truth: [`bug-triage/catalog.tsv`](https://github.com/d-torrance/M2/blob/bug-triage/bug-triage/catalog.tsv)}

Start with robust.m2:64-130 and inspect how the no-method stubs are installed, then compare them with the inheritance dispatchers in methods.m2:567-578. Review help.m2:143 and the behavior of methods symbol = and documentableMethods. Done should address the unwanted listing without removing the four real assignment methods or the dispatchers that do real work.

Written by the indexing model from the issue text.