docs(go): US English in the Go docstrings and tests

Prose only, on lines this branch adds. The Python/TypeScript/Java docstrings
keep their existing spellings -- not a mandate to rewrite them.

Author: sinha108

cldk/analysis/go/backend.py

@@ -475,7 +475,7 @@ def get_degraded(self) -> List[GoDegraded]:
         **Read this before trusting an absence.** A non-empty list means some L4 step fell back to
         a coarser result (``range_func``, ``unmapped_ssa``, ``no_vta``, …), so a path that *is*
         returned is still a real may-flow, but "no path" is not a proof over the affected packages
-        and callables. :meth:`taint` reports this on its own ledger rather than making the judgement
+        and callables. :meth:`taint` reports this on its own ledger rather than making the judgment
         for the caller; this accessor is how a caller inspects it directly.
         """
 
@@ -521,7 +521,7 @@ def taint(
         ``unresolved``.
 
         **Sources, sinks and sanitizers are the caller's to supply.** This SDK ships no Go framework
-        catalogue and derives no default set: a per-language vocabulary of taint sources is policy
+        catalog and derives no default set: a per-language vocabulary of taint sources is policy
         that rots, and this accessor is the mechanism.
 
         **A sanitizer is two mechanisms wearing one word**, told apart by shape. A bare ``str`` cuts

cldk/analysis/go/codeanalyzer/codeanalyzer.py

@@ -427,7 +427,7 @@ def _require_dataflow(self) -> None:
 
         One guard for the per-callable graphs and the slices: they come from the same analyzer pass
         and go dark together. It **raises** rather than returning empty because at a shallower level
-        an empty answer would mean "not analysed" while looking exactly like "no dependence" (D7).
+        an empty answer would mean "not analyzed" while looking exactly like "no dependence" (D7).
         """
         if self._level < self._DATAFLOW_LEVEL:
             raise CodeanalyzerUsageException(

cldk/analysis/go/go_analysis.py

@@ -257,7 +257,7 @@ def taint(
         m sources against n sinks in one traversal, reporting per pair: the witnesses in ``paths``,
         the pairs an absence claim can be built on in ``exhausted``, and everything else in
         ``unresolved``. The source/sink/sanitizer vocabulary is the caller's — no Go framework
-        catalogue ships. A non-empty :meth:`get_degraded` voids every ``exhausted`` certification,
+        catalog ships. A non-empty :meth:`get_degraded` voids every ``exhausted`` certification,
         because absence of a path is not a proof over an approximated graph.
         """
         return self.backend.taint(sources, sinks, sanitizers, depth=depth, max_paths=max_paths)

cldk/analysis/go/neo4j/neo4j_backend.py

@@ -102,7 +102,7 @@ def _slice_node(row: Dict[str, Any], module_key: Callable[[str], str]) -> SliceN
 
     The local twin is ``GoCodeanalyzer._slice_node``; the two share
     :func:`~cldk.analysis.commons.resolve.body_node_kind`, so a vertex a caller addressed through
-    ``resolve_value`` as a ``global`` comes back from a slice labelled a ``global`` on either
+    ``resolve_value`` as a ``global`` comes back from a slice labeled a ``global`` on either
     backend, and they differ only in where the fields are read from.
 
     ``row["var"]`` is the graph's name for the JSON's ``of`` (see
@@ -480,7 +480,7 @@ def get_source(self, node_id: str) -> str:
     # the value a vertex stands for arrives under the name the shared helpers expect.
     #
     # A STAND-IN IS A FIRST-CLASS VERTEX. ``:GoExternal`` nodes carry ``GO_HAS_BODY_NODE`` body
-    # nodes at L4, so the traversals must not be labelled ``:GoCallable``-only on the interior or
+    # nodes at L4, so the traversals must not be labeled ``:GoCallable``-only on the interior or
     # a flow *through* ``database/sql.DB.Query`` would be invisible — which is the very flow the
     # httpsql fixture gates. ``:GoCallable|GoExternal`` is therefore deliberate everywhere below.
     # =====================================================================================

tests/analysis/go/test_go_dataflow.py

@@ -5,7 +5,7 @@
 gated analyzer-side by ``TestGateL4_HTTPToSQLPath``; ``four_type_kinds.json`` is one declaration of
 each ``GoType.kind`` at ``-a 1``.
 
-**What is asserted and what is not.** These tests pin *behaviour a caller depends on* — that the
+**What is asserted and what is not.** These tests pin *behavior a caller depends on* — that the
 gated flow is found, that the four Go id/name traps are handled, that a refutation is only made
 where one is warranted. They deliberately do not pin edge counts: those move with every analyzer
 release and a test that fails on an improvement teaches nothing. Where a count appears it is
@@ -329,7 +329,7 @@ def test_paging_is_a_prefix_of_one_total_order(httpsql):
 
 def test_a_shallow_analysis_refuses_rather_than_answering_empty(tmp_path, monkeypatch):
     """At a level below the dataflow pass the three lists are absent, and an empty page there would
-    mean "not analysed" while looking exactly like "no dependence" (D7). So it raises, naming the
+    mean "not analyzed" while looking exactly like "no dependence" (D7). So it raises, naming the
     level to rebuild at."""
     shallow = _facade(tmp_path, monkeypatch, FOUR_KINDS, app="kinds", level=AnalysisLevel.symbol_table)
     with pytest.raises(CodeanalyzerUsageException, match="level 3"):