Lisp format list with parameter

There are three issues here: (1) The code you posted doesn't just have the problem of not using s; it's also trying to call the string "Sincerely" as a function; (2) quoting a list means you'll get exactly what's quoted (e.g., a list of symbols, not a list of values of variables); (3) calling format with lists.

(something other-stuff...) is a function call

When I put the code you posted into SBCL, I get some very specific and helpful output:

CL-USER> (defun closing (s)
           (format t "~{~a~}" ("Sincerely," "\n" s)))
; in: DEFUN CLOSING
;     ("Sincerely," "n" S)
; 
; caught ERROR:
;   illegal function call

;     (SB-INT:NAMED-LAMBDA CLOSING
;         (S)
;       (BLOCK CLOSING (FORMAT T "~{~a~}" ("Sincerely," "n" S))))
; 
; caught STYLE-WARNING:
;   The variable S is defined but never used.
; 
; compilation unit finished
;   caught 1 ERROR condition
;   caught 1 STYLE-WARNING condition

("Sincerely," "\n" s) is an illegal function call, since a string, like "Sincerely", can't have a function binding. Since SBCL sees the problem in that, it recognizes that the one thing that s might have been used for (i.e., an argument to a function call), can't happen. That's why you'll get the error, and then the associated style warning.

Creating lists of values

The second is probably answered in other questions already, but the short answer is that you want (list x y z), not '(x y z). The former calls the function list with the values of the variables x, y, and z, while the latter denotes a literal list of the symbols x, y, and z.

CL-USER> (let ((a 42)
               (b 89))
           (print '(a b))               ; a list of two symbols
           (print (list a b)))          ; a list of two numbers
(A B) 
(42 89) 

Format, iteration, &c.

The third is probably more interesting, since format has so many possibilities. The ~{ and ~} in your example are used for iterating over values in a list. First, let's look at a simple example: you can just use the format directive ~a and call format with the arguments you want to splice in:

CL-USER> (let ((closing "Sincerely")
               (name "Frank"))
           (format t "~a,~%~a" closing name))
Sincerely,
Frank

Now, if you need to print multiple values, you can use ~{ and ~} to have format iterate over a list of values:

CL-USER> (let ((closing "Sincerely")
               (names '("Frank" "John")))
           (format t "~a,~{~%~a~}" closing names))
Sincerely,
Frank
John

If the names are the values of variables, then you can either create a list containing those values:

CL-USER> (let ((closing "Sincerely")
               (name1 "Frank")
               (name2 "John"))
           (format t "~a,~{~%~a~}" closing (list name1 name2)))
Sincerely,
Frank
John

or you can change ~{ to ~@{ and have format read the remaining arguments as the list:

CL-USER> (let ((closing "Sincerely")
               (name1 "Frank")
               (name2 "John"))
           (format t "~a,~@{~%~a~}" closing name1 name2))
Sincerely,
Frank
John