Variation on Insertion Sort
Insertion sort maintains the following loop invariant:


After iteration $i$, the first $i$ positions in the array are the first $i$ positions of the input, in sorted order


Note that this doesn't mean that they need to be in their final positions for the sort to work at the end.  I'd say that this is the defining thing for "insertion sort", but that's not really a formal statement.

Insertion sort is not hard to turn into a recursive procedure.  The main routine you want is a helper called  insert-sorted such that consumes a sorted list and a number, and outputs a new sorted list (one longer) that includes the number.  You can write it in a way that is pretty much paradigmatic for Scheme (note, code just typed in, not tried):

(define (insert-sorted n l le)
    (if (null? l)
        (list n)
        (if (le n (car l))
            (cons n l)
            (cons (car l) (insert-sorted n (cdr l) le)))))


In words, if n comes before the first element of l or l is empty, then n goes in first position.  Otherwise, the list we want starts with the first element of l and ends with n in the right place in the tail of l.

With the helper, involves repeatedly calling insert-sorted to build up the sorted list.  If you want to follow the invariant exactly, then an approach like this will work:

(define (insertion-sort l le)
    (define (rec s l)
        (if (null? l) s (rec (insert-sorted (car l) s le) (cdr l))))
    (rec '() l))


However, this solution explicitly maintains s, the partially sorted list.  More idiomatic scheme would be to just use the call stack for this:

(define (insertion-sort l le)
    (if (null? l)
        '()
         (insert-sorted (car l) (insertion-sort (cdr l) le) le)))


I'll leave it to you to work out what the invariant for each implementation is.