Unexpected behavior with optimizeTailCall

;; Below functions are used to implement left `fold` one.
;; The goal is to make sure tail-call optimization is enabled during the recursion and reverted properly afterwards.
;; 
;; See reference : Wikipedia - Fold_(higher-order_function)"

;; I made several examples but I am surprised about the results...

(inScheme
(let ()

  ;; -------------------------------------------------------
  ;; Recursive helper
  ;; -------------------------------------------------------

  (defun rec ( function init l )
    "Apply FUNCTION to INIT and the head of L.
The result of this call is used as init and applied recursively to the tail of L"
    (if l
        (rec function (funcall function init (car l)) (cdr l))
      init
      ))

  ;; -------------------------------------------------------
  ;; Safe Revert (using `errset` or `unwindProtect`)
  ;; -------------------------------------------------------

  (defglobalfun foldl1_unwind_progn ( function l )
    "Left Fold: Apply combination FUNCTION to all elments of L starting from the left."
    (let ( ( tail_call_opt (status optimizeTailCall) )
           )
      (unwindProtect
        (progn (sstatus optimizeTailCall t) (rec function (car l) (cdr l)))
        (sstatus optimizeTailCall tail_call_opt)
        )
      ))

  (defglobalfun foldl1_unwind ( function l )
    "Left Fold: Apply combination FUNCTION to all elments of L starting from the left."
    (let ( ( tail_call_opt (status optimizeTailCall) )
           )
      (sstatus optimizeTailCall t)
      (unwindProtect
        (rec function (car l) (cdr l))
        (sstatus optimizeTailCall tail_call_opt)
        )
      ))

  (defglobalfun foldl1_unwind_nil ( function l )
    "Left Fold: Apply combination FUNCTION to all elments of L starting from the left."
    (let ( ( tail_call_opt (status optimizeTailCall) )
           )
      (sstatus optimizeTailCall t)
      (unwindProtect
        ;; Setting it to nil here does not seem to matter
        (progn (sstatus optimizeTailCall nil) (rec function (car l) (cdr l)))
        (sstatus optimizeTailCall tail_call_opt)
        )
      ))

  (defglobalfun foldl1_errset ( function l )
    "Left Fold: Apply combination FUNCTION to all elments of L starting from the left."
    (let ( ( tail_call_opt (status optimizeTailCall) )
           res )
      (sstatus optimizeTailCall t)
      (setq res (errset (rec function (car l) (cdr l))))
      (sstatus optimizeTailCall tail_call_opt)
      (if res (car res) (error "foldl1_errset - error occured: %N" errset.errset))
      ))

  ;; -------------------------------------------------------
  ;; Unsafe Revert
  ;; -------------------------------------------------------

  (defglobalfun foldl1_let ( function l )
    "Left Fold: Apply combination FUNCTION to all elments of L starting from the left."
    (let ( ( tail_call_opt (status optimizeTailCall) )
           res )
      (sstatus optimizeTailCall t)
      (setq res (rec function (car l) (cdr l)))
      (sstatus optimizeTailCall tail_call_opt)
      res))

  (defglobalfun foldl1_prog1 ( function l )
    "Left Fold: Apply combination FUNCTION to all elments of L starting from the left."
    (let ( ( tail_call_opt (status optimizeTailCall) )
           )
      (sstatus optimizeTailCall t)
      (prog1 (rec function (car l) (cdr l))) (sstatus optimizeTailCall tail_call_opt)
      ))

  (defglobalfun foldl1_putpropqq ( function l )
    "Left Fold: Apply combination FUNCTION to all elments of L starting from the left."
    (setf foldl1_putpropqq.tail_call_opt (status optimizeTailCall))
    (sstatus optimizeTailCall t)
    (prog1 (rec function (car l) (cdr l)) (sstatus optimizeTailCall foldl1_putpropqq.tail_call_opt))
    )

  ));scheme closure

;; -------------------------------------------------------
;; Testing done in the CIW
;; -------------------------------------------------------

/*
(tracef rec)
(foreach fun '( foldl1_unwind_progn foldl1_unwind foldl1_errset foldl1_let foldl1_prog1 foldl1_putpropqq)
  (println fun)
  (sstatus optimizeTailCall nil)
  (println (funcall fun 'times (list 1 2 3 4)))
  )
;*/

;; The only functions where tail-call optimization is actually working are:
;; foldl1_unwind foldl1_unwind_nil foldl1_errset

;; It feels like wrapping the call inside `errset` or `unwindProtect`
;; enables the switch but when using it in the same environment it is not yet taken in account.

;; Is this normal?
;; Am I missing something?

;; Thanks
;; Aurel