Finite State Machine code

If your FSM hardly ever changes, and performance is your primary concern, you can't beat this.

Translate it into simple structured code, in a progn or whatever, which you can do with any FSM. Here's the "C-ish" equivalent:

w = th = 0;
while(T){
  w++; th++;
  // Diggin' up gold!
  if (th >= 7){
    // Drinkin' old good whiskey
    th = 0;
  } else {
    // all this gold ought to be stored somewhere
    if (w >= 5){
      // Too much gold for today, let's sleep!
      w = 0;
      for (r = 0; r <= 3; r++){
        // sleepin'
      }
    }
  }
}

As of your second edit.

Ok, yeah now that you've shown how this is supposed to be called, CLOS is definitely the way to go here. Representing an object as a list of closures is less than optimal, if for no other reason that you then need to resort to (funcall (fifth a-miner)) in order to actually start it up (and consequently change that call every time you add a new "method" to your miner). There's also the problem that each "miner" you instantiate carries around its own independent functions (so good luck changing behavior at runtime or using any kind of inheritance for more complex modeling).

I suggest you take a look at this CLOS tutorial as well as chapters 16 and 17 of Practical Common Lisp

Here's a transliteration of your program using CLOS to act as a learning aid:

(defpackage :cl-miner (:use :cl))
(in-package :cl-miner)

(defclass miner ()
  ((wealth :accessor wealth :initarg :wealth :initform 0)
   (thirst :accessor thirst :initarg :thirst :initform 0)
   (rested :accessor rested :initarg :rested :initform 0)
   (state :accessor state :initarg :state :initform #'enter-mine-and-dig-for-nugget)))

;;;;;;;;;;;;;;; shortcuts
(defmethod enter ((m miner) a-state)
  (setf (state m) a-state))

(defun make-miner ()
  (make-instance 'miner))

;;;;;;;;;;;;;;; miner methods
(defmethod enter-mine-and-dig-for-nugget ((m miner))
  (format t "~&Diggin' up gold!")
  (incf (wealth m))
  (incf (thirst m))
  (if (>= (thirst m) 7)
      (enter m #'quench-thirst)
      (enter m #'visit-bank-and-deposit-gold)))

(defmethod quench-thirst ((m miner))
  (format t "~&Drinkin' old good whiskey")
  (setf (thirst m) 0)
  (enter m #'enter-mine-and-dig-for-nugget))

(defmethod visit-bank-and-deposit-gold ((m miner))
  (format t "~&All this gold ought to be stored somewhere!")
  (incf (wealth m))
  (if (>= (wealth m) 5)
      (progn 
        (format t "~&Too much gold for today, let's sleep!")
        (enter m #'go-home-and-sleep-till-rested)
        (setf (wealth m) 0))
      (enter m #'enter-mine-and-dig-for-nugget)))

(defmethod go-home-and-sleep-till-rested ((m miner))
  (dotimes (i 4)
    (format t "~&Sleepin'"))
  (enter m #'enter-mine-and-dig-for-nugget))

(defmethod work ((m miner))
  (dotimes (n 30)
    (funcall (state m) m)))

(let ((a (make-miner)))
  (work a))

I was going to compare them for performance, but I couldn't get your revised version to run (it gave me an "unhandled memory fault" error which is something I haven't seen before).

Can you comment on what the goal/output of this program is supposed to be? How you're supposed to use it? It looks like make-miner just returns a list of functions, which doesn't sound useful on its own.

Some preliminary comments:

You can cut the while macro. CL provides you with many iteration constructs (do, dotimes, dolist, mapcar and friends, and loop). That last one can do what you want here (and lots more if you feel like reading);

(loop while (<= rested 3)
      do (format t "~&Sleepin'")
      do (incf rested))

Since you reset rested to 0 later in the same block anyway, you could also just do

(loop repeat 4 do (format t "~&Sleepin'"))

or

(dotimes (i 4) do (format t "~&Sleepin'"))

Common Lisp convention is to use dashed-lower-case-names rather than CamelCaseNames.

cond clauses don't need an explicit progn, but read on first

Wherever you've got (cond ([test] [clause]) (t [clause])), you can instead write (if [test] [clause] [clause]). For example,

(if (>= wealth 5) 
    (progn 
      (format t "~&Too much gold for today, let's sleep!")
      (enter 'GoHomeAndSleepTillRested)
      (setf wealth 0))
    (EnterMineAndDigForNugget))

You do actually need the progn here. In general, you should use cond where you'd normally use if/elseif/else in other languages (case is actually the switch analogue), and use if/when/unless where you can to signal intent.