fix(neo4j)!: stop deleting other analyzers' graphs; artifact text whole and on the graph

[rahlk]

Closes #116.

The bug behind the reported crash

#116 was filed as "Neo4j transaction too big". The out-of-memory error is real, but it is a
symptom — and it is what prevented data loss rather than causing it.

Before every write whose stored schema version did not match, the writer ran:

MATCH (n) WHERE n._module IS NOT NULL AND NOT n:CanNode DETACH DELETE n

:CanNode is a label only this analyzer applies, so "has _module, lacks :CanNode" was read as
"stale TypeScript". It is not. codeanalyzer-python sets _module on four node types
(neo4j/schema.py:91,107,131,160) and codeanalyzer-java sets it in GraphProjector.java:256,273
— and neither applies :CanNode. That predicate is an exact description of their nodes.

So pointing cants at a shared Neo4j deleted the python and java graphs before writing anything of
its own. It only failed loudly because the delete exhausted dbms.memory.transaction.total.max and
rolled back. A smaller foreign graph, or a roomier server, and it would have succeeded silently.

What changes

Deletion is the operator's call, not the analyzer's.

• Default push — MERGE current nodes over whatever is there and delete nothing. The per-module
  purge and the orphan prune are now --eager-only, and a schema-version mismatch forces a full
  re-UPSERT instead of a wipe.

• --eager — purge this application's graph and rebuild, scoped twice:

  MATCH (n:CanNode) WHERE n.id STARTS WITH $prefix
  CALL { WITH n DETACH DELETE n } IN TRANSACTIONS OF 5000 ROWS

  :CanNode keeps it to nodes this analyzer wrote; the id prefix keeps it to this application, so
  a second app in the same database survives; batched, because one transaction over a whole
  application is what hit the cap in the first place.

The tradeoff, stated plainly: declarations removed from a source file now linger until someone runs
--eager. A stale node is visible and recoverable; another tool's silently deleted edges are
neither. codeanalyzer-java reaches the same conclusion for its snapshot path in
CypherWriter.java:40-52.

:Artifact now carries source and text_truncated→source. Python has emitted artifact text
since it shipped the layer (neo4j/schema.py:213); omitting it here meant a consumer reading the
same neutral :Artifact node got text from python and nothing from TypeScript.

Artifact text is captured whole — the byte cap is gone. Removed the 256 KiB cap,
--artifact-text-max-bytes, and the text_truncated flag. A truncated source reads exactly like
a complete small file, so it forces every consumer to carry a flag to tell them apart — and the flag
could not even do that, since text_truncated: false covered both "complete" and "capture
disabled". On vscode it bought little: 32 of 4,953 artifacts were clipped. --no-artifact-text
remains, as the one unambiguous opt-out.

BREAKING

• --artifact-text-max-bytes is no longer accepted; text_truncated is gone from analysis.json
  and from the :Artifact node.
• Deletion no longer happens without --eager.
• Diverges from python, which still caps and reports the flag — filed there
  (Artifact text: drop the byte cap and text_truncated, to match typescript codeanalyzer-python#172, Artifact text: drop the byte cap and text_truncated, to match typescript codeanalyzer-java#214) so all three land
  on one answer.

Verification

Against a live Neo4j capped at the reporter's exact 2.7 GiB, with a python graph planted
alongside a 1,841-module / 124,866-node superset-frontend graph:

	python nodes	outcome
default push	survive	graph updated in place
--eager push	survive	this app purged and rebuilt

Previously either push would have deleted them. Suite: 232 pass / 6 skip / 0 fail; typecheck,
build, gen:schema, gen:readme all clean.

I also removed a test that had codified the bug as intent — it asserted the wipe was
"intentionally UNANCHORED" and looped over the statements asserting
not.toContain("MATCH (n:CanNode"). It is replaced by three tests asserting the inverse safety
property, including an explicit not.toContain("NOT n:CanNode") on the lethal shape.

Follow-ups, not in this PR

• content_hash is never written to the graph (project.ts omits it, bolt.ts reads it), so the
  incremental diff always concludes "everything changed" and every push is a full re-upsert.
• The sibling analyzers have the same unanchored-delete exposure in their per-module purges:
  Neo4j: never delete by default; gate purge on --eager and scope it to this analyzer codeanalyzer-python#171, Neo4j: never delete by default; gate purge on --eager and scope it to this analyzer codeanalyzer-java#213.