docs(go): add switch vs if control-flow guidance

- Expand 210-go Simplicity section with discrete outcomes and examples
- Cross-link from go-rust-systems skill and go-idioms reference

Author: d-padmanabhan

rules/210-go.mdc

@@ -398,6 +398,37 @@ func KnownAccounts() map[string]Account {
 - **Make the Zero Value Useful**: Types should work correctly when zero-initialized
 - **A Little Copying is Better Than a Little Dependency**: Prefer copying small, stable code over adding dependencies
 
+### Switch vs if / else (control flow)
+
+- **Prefer `switch`** when branching on **one** expression with **several discrete outcomes** (for example `r.Method`, CLI subcommand name, enum-like string or int) or when using a **type switch** (`switch v := x.(type)`).
+- **Prefer `if`** for **`if err != nil`** and error shaping (`errors.Is` / `errors.As`), **early returns**, **boolean** guards, **two** clear branches, or when conditions are **not** the same discriminant.
+- **`switch {` … `case cond:`** is fine when a flat list of conditions reads better than a long `else if` ladder; pick whichever is **clearer**.
+- **Do not** force `switch` where a **method on an interface** or a **small registry** (for example map of handlers) is the simpler extension point.
+
+```go
+//  BAD: Same discriminant repeated in else-if chain
+func handleVerb(verb string) error {
+    if verb == "GET" {
+        return nil
+    } else if verb == "POST" {
+        return nil
+    } else if verb == "DELETE" {
+        return nil
+    }
+    return fmt.Errorf("unknown verb")
+}
+
+//  GOOD: switch on one expression
+func handleVerb(verb string) error {
+    switch verb {
+    case "GET", "POST", "DELETE":
+        return nil
+    default:
+        return fmt.Errorf("unknown verb")
+    }
+}
+```
+
 ### Dependency Management
 
 **Proverb**: "A little copying is better than a little dependency"

skills/go-rust-systems/SKILL.md

@@ -78,6 +78,10 @@ func TestAdd(t *testing.T) {
 }
 ```
 
+### Control flow: `switch` vs `if` / `else`
+
+Prefer **`switch`** for multi-way dispatch on one expression (and type switches); keep **`if`** for errors, booleans, guards, and two-branch logic. Do not rewrite `errors.Is` / `errors.As` chains just to use `switch`. Detail: `rules/210-go.mdc` (Simplicity & Idiomatic Go) and `references/go-idioms.md`.
+
 ### Mandatory Hardening Add-On (Go)
 
 For HTTP/API client code, always apply the hardening checks from

skills/go-rust-systems/references/go-idioms.md

@@ -164,6 +164,25 @@ func FindItem(items []Item, predicate func(Item) bool) *Item {
 }
 ```
 
+## Switch vs if / else
+
+**When to use `switch`**
+
+- One expression, many discrete values (HTTP method, command name, format string, enum-like int).
+- Dynamic types on an interface: `switch v := x.(type)`.
+
+**When to keep `if`**
+
+- Error handling (`if err != nil`, `errors.Is`, `errors.As`).
+- Two branches, boolean guards, early returns, or unrelated predicates.
+
+**Other**
+
+- `switch {` with `case cond:` is idiomatic when it reads cleaner than `else if`; choose clarity.
+- Prefer methods on interfaces or a small handler map when that scales better than a growing `switch`.
+
+See [Effective Go — Switch](https://go.dev/doc/effective_go#switch) and `rules/210-go.mdc` (Simplicity & Idiomatic Go).
+
 ## Avoid interface{} When Possible
 
 **Proverb**: "interface{} says nothing"