Let a ring register a Groebner basis strategy for gb to find

This issue was triaged from [`bugs/dan/0-gb-strategies`](https://github.com/Macaulay2/M2/blob/388c1ff0ce30d83751dea7bc7eac77fdc1305dd7/bugs/dan/0-gb-strategies), 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

```text
BooleanGB contains an optional strategy for doing all gb's over rings from a
certain class. This should be done by:

- at polynomial ring creation time, registering the strategy name
(symbol) in the ring where gb can find it and use it
- letting the strategy be inherited by quotient rings of the ring, but
not by polynomial rings over the ring
- letting gb accept the strategy name, too

Use Strategy or Algorithm ??
```

### Where it stands today

Not done, and both halves of the file's design are still visible in the current code.

### The state today

`gb.m2` keeps a fixed `RawStrategyCodes` table and errors on an unrecognized strategy name, so there
is no way for a ring to introduce one. And `BooleanGB` does exactly what the file was written to
avoid: it exports `gbBoolean` as a separate entry point, rather than registering a strategy that
ordinary `gb` would find.

### What the file proposes

1. At polynomial-ring creation, register a strategy name in the ring where `gb` can find it.
2. Let quotient rings of that ring inherit it — but not polynomial rings *over* it.
3. Let `gb` accept the strategy name too.

The second point is the subtle one and worth preserving in any implementation: a Boolean strategy is
valid for `R/I` because the elements are the same kind of thing, and invalid for `R[y]` because they
are not.

### Notes for whoever picks this up

`Strategy` versus `Algorithm` is left open in the file. The tree has since settled towards `Strategy`
with hook-based dispatch — `kernel RingMap` (`ringmap.m2:240`) and `intersect` both work that way now
— so the machinery this asks for partly exists in a different form, and the question is whether ring-
registered strategies should be expressed as hooks rather than as a name looked up in the ring.

_{`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 gb.m2's RawStrategyCodes table and the BooleanGB implementation that exports gbBoolean. Compare their dispatch with the hook-based approaches in ringmap.m2:240 and intersect. Done means a ring can register a strategy for gb, quotient rings inherit it, polynomial extensions do not, and gb accepts the strategy name.

Written by the indexing model from the issue text.