feat(8.0)!: flip requireSubtype default to true (BRAINY-8.0-SUBTYPE-CONTRACT § C-1)

Brainy 8.0 makes subtype required by default on every public write path
(`add`, `addMany`, `update`, `relate`, `relateMany`, `updateRelation`,
import). Per the locked C-1 contract, every entity and relation gets a
non-empty subtype string by the time the storage layer sees it.

OPT-OUT REMAINS FULLY SUPPORTED

The runtime flag is still consumer-controlled. Three opt-out paths
cover migration / legacy fixtures / typed escape:

- `new Brainy({ requireSubtype: false })` — last-resort: turn off the
  contract entirely. Recommended only for migration windows or test
  fixtures that legitimately can't supply a subtype.
- `new Brainy({ requireSubtype: { except: [NounType.Thing, ...] } })` —
  per-type allowlist: strict everywhere except the listed types.
- `brain.requireSubtype(type, options)` — per-type registration with
  optional vocabulary. Composes with the brain-wide flag.

Default is now `true`. Opt-out is explicit and documented; nothing
silently degrades.

TEST SWEEP

Bulk-applied `requireSubtype: false` to every `new Brainy({...})` call
site across 120 test files. Three sed patterns covered the shapes:
  - `new Brainy({` → `new Brainy({ requireSubtype: false,`
  - `new Brainy<T>({` → `new Brainy<T>({ requireSubtype: false,`
  - `new Brainy()` → `new Brainy({ requireSubtype: false })`

tests/helpers/test-factory.ts → createTestConfig() defaults
`requireSubtype: false` so test files using the helper inherit the
opt-out without per-site edits.

The test sites that DO exercise subtype semantics (the
subtype-and-facets suite, the strict-mode-self-test suite, the verb-
subtype-and-enforcement suite, etc.) already pass real subtypes — they
were the 7.30.x acceptance tests for this contract. Those tests
continue to pass unchanged.

CHANGES

src/brainy.ts
- normalizeConfig() — `requireSubtype` default `false` → `true`.
  Comment refreshed to document the three opt-out paths.

tests/* (120 files)
- Bulk-edited brain construction sites. No functional test changes; the
  opt-out preserves the test author's original intent.

tests/helpers/test-factory.ts
- createTestConfig() base config gains `requireSubtype: false`.

NO-OP for consumers who were already passing subtype on every write.

For consumers who weren't, the upgrade path is one of the three opt-out
forms above. Migration recipe documented in 8.0 release notes (next
commit).

VERIFICATION

- npx tsc --noEmit: clean
- npm test: 1408 / 1409 (same pre-existing race-condition outstanding;
  no other regressions from the flip)

tests/integration/multi-process-safety.test.ts

@@ -45,7 +45,7 @@ describe('Multi-process safety + read-only mode', () => {
 
   describe('ReaderMode enforcement', () => {
     it('rejects every mutation when opened via openReadOnly()', async () => {
-      writer = new Brainy({ storage: { type: 'filesystem', rootDirectory: dir } })
+      writer = new Brainy({ requireSubtype: false, storage: { type: 'filesystem', rootDirectory: dir } })
       await writer.init()
       await writer.add({ data: 'seed entity', type: NounType.Concept })
       await writer.flush()
@@ -67,7 +67,7 @@ describe('Multi-process safety + read-only mode', () => {
     })
 
     it('flush() and close() are safe to call in read-only mode', async () => {
-      writer = new Brainy({ storage: { type: 'filesystem', rootDirectory: dir } })
+      writer = new Brainy({ requireSubtype: false, storage: { type: 'filesystem', rootDirectory: dir } })
       await writer.init()
       await writer.add({ data: 'thing', type: NounType.Concept })
       await writer.flush()
@@ -105,7 +105,7 @@ describe('Multi-process safety + read-only mode', () => {
         rootDir: dir
       }))
 
-      const blocked = new Brainy({ storage: { type: 'filesystem', rootDirectory: dir } })
+      const blocked = new Brainy({ requireSubtype: false, storage: { type: 'filesystem', rootDirectory: dir } })
       await expect(blocked.init()).rejects.toThrow(/another writer holds/i)
       // Don't track `blocked` for afterEach cleanup since init failed.
     })
@@ -113,16 +113,16 @@ describe('Multi-process safety + read-only mode', () => {
     it('allows a second in-process writer with a warning (same PID)', async () => {
       // Two Brainy instances in the same Node process: not the dangerous
       // cross-process case. Should succeed (with a console warning).
-      writer = new Brainy({ storage: { type: 'filesystem', rootDirectory: dir } })
+      writer = new Brainy({ requireSubtype: false, storage: { type: 'filesystem', rootDirectory: dir } })
       await writer.init()
 
-      const second = new Brainy({ storage: { type: 'filesystem', rootDirectory: dir } })
+      const second = new Brainy({ requireSubtype: false, storage: { type: 'filesystem', rootDirectory: dir } })
       await expect(second.init()).resolves.toBeUndefined()
       await second.close()
     })
 
     it('lets a reader open while a writer is live', async () => {
-      writer = new Brainy({ storage: { type: 'filesystem', rootDirectory: dir } })
+      writer = new Brainy({ requireSubtype: false, storage: { type: 'filesystem', rootDirectory: dir } })
       await writer.init()
       await writer.add({ data: 'concurrent', type: NounType.Concept })
       await writer.flush()
@@ -137,10 +137,10 @@ describe('Multi-process safety + read-only mode', () => {
     })
 
     it('honors { force: true } to override an existing lock', async () => {
-      writer = new Brainy({ storage: { type: 'filesystem', rootDirectory: dir } })
+      writer = new Brainy({ requireSubtype: false, storage: { type: 'filesystem', rootDirectory: dir } })
       await writer.init()
 
-      const second = new Brainy({
+      const second = new Brainy({ requireSubtype: false,
         storage: { type: 'filesystem', rootDirectory: dir },
         force: true
       })
@@ -151,14 +151,14 @@ describe('Multi-process safety + read-only mode', () => {
 
   describe('Flush-request RPC', () => {
     it('in-process call just flushes', async () => {
-      writer = new Brainy({ storage: { type: 'filesystem', rootDirectory: dir } })
+      writer = new Brainy({ requireSubtype: false, storage: { type: 'filesystem', rootDirectory: dir } })
       await writer.init()
       const ok = await writer.requestFlush({ timeoutMs: 1000 })
       expect(ok).toBe(true)
     })
 
     it('cross-instance request reaches the writer (same-process simulation)', async () => {
-      writer = new Brainy({ storage: { type: 'filesystem', rootDirectory: dir } })
+      writer = new Brainy({ requireSubtype: false, storage: { type: 'filesystem', rootDirectory: dir } })
       await writer.init()
       await writer.add({ data: 'pre-request', type: NounType.Concept })
 
@@ -174,7 +174,7 @@ describe('Multi-process safety + read-only mode', () => {
     it('returns false when no writer is running', async () => {
       // Seed some data, then close the writer. The data dir exists but no
       // writer is listening for flush requests.
-      writer = new Brainy({ storage: { type: 'filesystem', rootDirectory: dir } })
+      writer = new Brainy({ requireSubtype: false, storage: { type: 'filesystem', rootDirectory: dir } })
       await writer.init()
       await writer.add({ data: 'orphan', type: NounType.Concept })
       await writer.flush()
@@ -191,7 +191,7 @@ describe('Multi-process safety + read-only mode', () => {
 
   describe('Diagnostics on a reader', () => {
     beforeEach(async () => {
-      writer = new Brainy({ storage: { type: 'filesystem', rootDirectory: dir } })
+      writer = new Brainy({ requireSubtype: false, storage: { type: 'filesystem', rootDirectory: dir } })
       await writer.init()
       await writer.add({ data: 'one', type: NounType.Concept, metadata: { tag: 'a' } })
       await writer.add({ data: 'two', type: NounType.Concept, metadata: { tag: 'b' } })