anchor.diff:     cyclic graphs.
   
      This returns two objects: a lookup of vertex to its immediate dominator,
  -   and a DAG with edges from dominators to their immediate children."
  -
  +   and a DAG with edges from dominators to their immediate children.
  +
  +   ### Example:
  +   ```cl
  +   > (define g (make-graph))
  +   > (define doms
  +   .   (let [(a (add-vertex! g :a))
  +   .         (b (add-vertex! g :b))
  +   .         (c (add-vertex! g :c))
  +   .         (d (add-vertex! g :d))]
  +   .     (add-edge! a b)
  +   .     (add-edge! a c)
  +   .     (add-edge! b c)
  +   .     (add-edge! c b)
  +   .     (add-edge! b d)
  +   .
  +   .     (dominators a)))
  +   > (.> doms (get-vertex g :b))
  +   out = «vertex: \"a\"»
  +   > (.> doms (get-vertex g :c))
  +   out = «vertex: \"a\"»
  +   > (.> doms (get-vertex g :d))
  +   out = «vertex: \"b\"»
  +   ```"
  +  (assert-type! root vertex)
     (let* [(vertices '())
            (dominators {})
            (dom-graph  (make-graph))]
  
positive.code:  super-vertices, and other nifty features."
  
  (import data/struct ())
  
  (defstruct graph
    "Create a new, empty graph."
    (fields
      (immutable vertices)
      (immutable vertex-lookup))
    (constructor new
      (lambda () (new '() {}))))
  
  
negative.code:   (assert-type! to   vertex)
  
    (when (/= (vertex-graph from) (vertex-graph to))
      (format 1 "(add-edge! {#from} {#to}): vertex value cannot be nil"))
  
    (.<! (vertex-out-edges from) to   true)
    (.<! (vertex-in-edges  to)   from true)
  