docs: backfill TOC + decision trees, fix review findings

- Add ## Contents and ## Decision Tree to all 10 existing pattern files
- Fix embed_as/1 semantics inversion in types.md (:self → :dump)
- Fix fabricated __meta__.changes reference in changesets.md
- Fix default primary key type (:integer → :id) in schemas.md
- Combine @impl subsections into single "Minimal Callback Annotation"

patterns/error-handling.md

@@ -2,6 +2,23 @@
 
 Patterns extracted from Elixir's standard library source code.
 
+## Contents
+
+1. [The `with` Macro — Normalized Error Clauses](#1-the-with-macro--normalized-error-clauses)
+2. [Real-World `with` — Multi-Step Fallible Operations](#2-real-world-with--multi-step-fallible-operations)
+3. [Another `with` — Error Info Extraction](#3-another-with--error-info-extraction)
+4. [`{:ok, value}` / `:error` Convention (Map.fetch)](#4-ok-value--error-convention-mapfetch)
+5. [Bang Functions: Raise on Error (`fetch!` vs `fetch`)](#5-bang-functions-raise-on-error-fetch-vs-fetch)
+6. [Exception Structure: `defexception` Fields](#6-exception-structure-defexception-fields)
+7. [Custom `exception/1` Callback for Ergonomic Raising](#7-custom-exception1-callback-for-ergonomic-raising)
+8. [`raise` Macro Internals: Compile-Time Type Resolution](#8-raise-macro-internals-compile-time-type-resolution)
+9. [Error Normalization: Erlang → Elixir Exception Translation](#9-error-normalization-erlang--elixir-exception-translation)
+10. [`blame/2` Callback: Enriching Exceptions After the Fact](#10-blame2-callback-enriching-exceptions-after-the-fact)
+11. [Guards for Type Dispatch in Error Handling](#11-guards-for-type-dispatch-in-error-handling)
+12. [The `:error` / `{:error, reason}` Convention Split](#12-the-error--error-reason-convention-split)
+13. [`reduce_while` — Early Exit Without Exceptions](#13-reduce_while--early-exit-without-exceptions)
+14. [Three-Tier Error Strategy in Map Operations](#14-three-tier-error-strategy-in-map-operations)
+
 ---
 
 ## 1. The `with` Macro — Normalized Error Clauses
@@ -1400,4 +1417,19 @@ end
 
 **Why:** The three-tier pattern only makes sense when failure is a real possibility and different callers genuinely need different responses to that failure. Don't cargo-cult it onto functions that always succeed or have a single calling context.
 
+## Decision Tree
+
+- If you have 2+ sequential steps that each return a value to pattern-match → use `with` with normalized error shapes (Pattern 1)
+- If the caller only cares success vs failure (not which step failed) → use `with` + `else _ -> :error` catch-all (Pattern 2)
+- If extracting nested data from loosely-structured inputs (stacktraces, metadata) → chain pattern matching in `with` (Pattern 3)
+- If a function has exactly one failure mode obvious from context → return bare `:error` (Pattern 4)
+- If failure means a bug (preconditions guarantee success) → provide a bang variant that raises (Pattern 5)
+- If callers need to programmatically inspect error context → use `defexception` with structured fields (Pattern 6)
+- If the exception message is computed from multiple fields or requires validation → override `exception/1` (Pattern 7)
+- If wrapping an Erlang library that returns raw error atoms/tuples → normalize to Elixir exceptions at the boundary (Pattern 9)
+- If you can provide expensive but helpful context (did-you-mean suggestions) → implement `blame/2` (Pattern 10)
+- If multiple distinct failure modes exist → use `{:error, reason}` tuples; if only one → use bare `:error` (Pattern 12)
+- If you need early exit from iteration without exceptions → use `reduce_while` with `{:cont, acc}` / `{:halt, acc}` (Pattern 13)
+- If designing a module with lookup operations for different caller needs → provide three tiers: get/fetch/fetch! (Pattern 14)
+
 <!-- PATTERN_COMPLETE -->