ocaml: phase 5.1 bfs.ml baseline (20/20 pass)

Graph BFS using Queue + Hashtbl visited-set + List.assoc_opt + List.iter.
Returns 6 for a graph where A reaches B/C/D/E/F. Demonstrates 4 stdlib
modules (Queue, Hashtbl, List) cooperating in a real algorithm.

lib/ocaml/baseline/bfs.ml

@@ -0,0 +1,43 @@
+(* Baseline: graph BFS using Queue + Hashtbl visited set.
+   Returns the count of reachable nodes. *)
+
+(* Adjacency as an assoc list of (node, neighbors). *)
+let graph =
+  [ ("A", ["B"; "C"])
+  ; ("B", ["D"])
+  ; ("C", ["D"; "E"])
+  ; ("D", ["F"])
+  ; ("E", ["F"])
+  ; ("F", [])
+  ]
+;;
+
+let neighbors n =
+  match List.assoc_opt n graph with
+  | None -> []
+  | Some ns -> ns
+;;
+
+let bfs start =
+  let visited = Hashtbl.create 16 in
+  let q = Queue.create () in
+  Queue.push start q ;
+  Hashtbl.add visited start true ;
+  let rec loop () =
+    if Queue.is_empty q then ()
+    else
+      let v = Queue.pop q in
+      List.iter
+        (fun n ->
+          if not (Hashtbl.mem visited n) then begin
+            Hashtbl.add visited n true ;
+            Queue.push n q
+          end)
+        (neighbors v) ;
+      loop ()
+  in
+  loop () ;
+  Hashtbl.length visited
+;;
+
+bfs "A"

lib/ocaml/baseline/expected.json

@@ -1,5 +1,6 @@
 {
   "anagrams.ml": 3,
+  "bfs.ml": 6,
   "btree.ml": 39,
   "calc.ml": 13,
   "closures.ml": 315,

plans/ocaml-on-sx.md

@@ -407,6 +407,10 @@ _Newest first._
   binary search tree (`type 'a tree = Leaf | Node of 'a * 'a tree *
   'a tree`) with insert + in-order traversal. Tests parametric ADT,
   recursive match, List.append, List.fold_left.
+- 2026-05-08 Phase 5.1 — bfs.ml baseline (20/20 pass). Graph
+  breadth-first search using Queue + Hashtbl visited-set + List.assoc_opt
+  + List.iter. Returns the count of reachable nodes (6 for the demo
+  graph A→B→D→F, A→C→{D,E}, E→F).
 - 2026-05-08 Phase 1 — type annotations on let-bindings and parens
   expressions (+4 tests, 473 total). `let NAME [PARAMS] : T = expr`
   and `(expr : T)` parse and skip the type source. Runtime no-op