sorting a numerical list using basic scheme
So to answer your specific question, yes you can greatly simplify your algorithm in a couple places:

(list-tail numList (- (length numList) 1))


So you're taking the last n - 1 elements of a list of length n? That's exactly:

(cdr numList)


As for this part:

(reverse (list-tail (reverse numList) 1))


So the list-tail will return a list of size 1, so you can drop the outer-most reverse entirely.  Secondly, what are you getting here? Just the first element right? Which is to say...

(car numList)


So putting that together, we end up with this (+/- missing parens)

(define ra-sort
  (lambda (numList)
    (cond
      ((null? numList) '())
      ((= (car numList) (apply max numList))
          (cons (car numList) (ra-sort (cdr numList))))
          (else (ra-sort (append (cdr numList) (list (car numList))))
      )))


Ok so now think about this algorithm. At each iteration, we're checking if the head is in the right place, if it is we go to the next element, else we rotate the whole array. Checking if the first element is the max takes O(n) time. We expect to have to do this O(n) times per element, for every element... so we end up with O(n^3).

A simple insertion sort, which is what I think you're trying to implement, should be only O(n^2). So try to redo your algorithm so that instead of just checking if the first elem is the maximum one, you actually find it. So your inner clause would be something like:

(cons maxElem                               # largest element
    (ra-sort (remove-elem numList maxElem)) # + rest of list
)


That'll get you to where you want to be. At least for this sorting algorithm.