Sobre recursao de cauda

Notei uma diferenca na utilizacao da recursao com cauda:

• Quando e utilizada com o "do" ele executa novamente toda a funcao.
• Quando e utilizada com o "loop" ela executa novamente apenas o laco "loop"

Tambem reparei que quando estamos utilizando o "loop" no commando recur enviamos os parametros para o loop e nao para a funcao, como no exemplo:

forca.core=> (defn fib[x]
        #_=>     (loop [a 1 b 1 numero 2]
        #_=>         (if
        #_=>             (= numero x) b
        #_=>             (recur b (+ a b) (inc numero))
        #_=>         )
        #_=>     ))

Porem no exemplo do "forca" utilizamos o "recur" com o "do" e isso nao acontece: Neste caso enviamos os parametros para a propria funcao.

(defn jogo [vidas palavra acertos]
    (cond 
        (= vidas 0) (perdeu)
        (acertou-a-palavra-toda? palavra acertos) (ganhou)
        :else
        (let [chute (le-letra!)]
            (if (acertou? chute palavra)
                (do 
                    (println "Acertou a letra!")
                    (recur vidas palavra (conj acertos chute)))
                (do    
                    (println "Errou a letra! Perdeu vida!")
                    (recur (dec vidas) palavra acertos))))))

Pergunta:

• Quando o recur chama a propria funcao recursivamente ?
• Quando o recur chama o loop recursivamente ?
• Quando o recur chama o do recursivamente ?
• E porque isso?
• Alem disso voces tem algum material de como o recur funciona, porque parece magica ele nao empilhar (nao achei conteudos tao faceis com os do Alura)

Obrigado !!