anchor.diff:  (define (resolve-variables form)
     (resolve-variables-aux form ()))
               
  -;;; Classify all variables into read-only and potentially read-write
  +;;; Classify all variables into read-only and (potentially)
  +;;; read-write, or early function (a read-only variable with a
  +;;; function value that is potential ready before its definition).
  +;;;
  +;;; A state is attached to each varrec:
   ;;;
   ;;; I (4) - initial state
   ;;; r (5) - read before a define
  
positive.code: ;;; ref           R W E F r r !
  ;;; set!          W W E E E E !
  ;;;
  ;;; An "acccess" attribute is added to each varrec, indicating whether
  ;;; the access style is read-only, written, or early-function.
  
  (define-trivial-walker classify-variables ())
  
  
negative.code: ;;; => (lambda ((closure (fv (source fv ...) ...)) ...) ... (fv ...) ...)
  ;;;
  ;;; Also adds the boxed attribute to origin varrecs.
  
  ;;; When we reach this phase, all uses of a variable refer to the same
  ;;; varrec.  This phase determines which uses can access the variable
  ;;; directly, and which need to go via a closure.  The former get the
  ;;; "origin" varrec (this has an origin attribute of false).  The
  ;;; latter get new varrecs, with their origin attribute pointing to
  ;;; the origin varrec.
  ;;;
  ;;; This is implemented by adding a closure stack to each origin
  ;;; varrec.  The closure stack is an alist from the binding form depth
  ;;; to the appropriate varrec for uses within that binding form.
  
  (define (resolve-closure-var varrec depth closure-cell)
    (let* ((closure-stack (varrec-attr varrec 'closure-stack))
  