Split Analysis into Analysis+ToolUse and Observation, add message_id (#747)

Refactor agent provenance so that the decision (thought + tool
selection) and the result (observation) are separate DAG entities:

  Question ← Analysis+ToolUse ← Observation ← ... ← Conclusion

Analysis gains tg:ToolUse as a mixin RDF type and is emitted
before tool execution via an on_action callback in react().
This ensures sub-traces (e.g. GraphRAG) appear after their
parent Analysis in the streaming event order.

Observation becomes a standalone prov:Entity with tg:Observation
type, emitted after tool execution. The linear DAG chain runs
through Observation — subsequent iterations and the Conclusion
derive from it, not from the Analysis.

message_id is populated on streaming AgentResponse for thought
and observation chunks, using the provenance URI of the entity
being built. This lets clients group streamed chunks by entity.

Wire changes:
- provenance/agent.py: Add ToolUse type, new
  agent_observation_triples(), remove observation from iteration
- agent_manager.py: Add on_action callback between reason() and
  tool execution
- orchestrator/pattern_base.py: Split emit, wire message_id,
  chain through observation URIs
- orchestrator/react_pattern.py: Emit Analysis via on_action
  before tool runs
- agent/react/service.py: Same for non-orchestrator path
- api/explainability.py: New Observation class, updated dispatch
  and chain walker
- api/types.py: Add message_id to AgentThought/AgentObservation
- cli: Render Observation separately, [analysis: tool] labels

tests/unit/test_agent/test_explainability_parsing.py

@@ -13,6 +13,7 @@ from trustgraph.api.explainability import (
     StepResult,
     Synthesis,
     Analysis,
+    Observation,
     Conclusion,
     TG_DECOMPOSITION,
     TG_FINDING,
@@ -20,6 +21,7 @@ from trustgraph.api.explainability import (
     TG_STEP_RESULT,
     TG_SYNTHESIS,
     TG_ANSWER_TYPE,
+    TG_OBSERVATION_TYPE,
     TG_ANALYSIS,
     TG_CONCLUSION,
     TG_DOCUMENT,
@@ -74,6 +76,11 @@ class TestFromTriplesDispatch:
         entity = ExplainEntity.from_triples("urn:a", triples)
         assert isinstance(entity, Analysis)
 
+    def test_dispatches_observation(self):
+        triples = _make_triples("urn:o", [PROV_ENTITY, TG_OBSERVATION_TYPE])
+        entity = ExplainEntity.from_triples("urn:o", triples)
+        assert isinstance(entity, Observation)
+
     def test_dispatches_conclusion_unchanged(self):
         triples = _make_triples("urn:c",
                                 [PROV_ENTITY, TG_CONCLUSION, TG_ANSWER_TYPE])