sexp.lisp: Option to insert line breaks.

Instead of outputting everything on one line, it's be nice to leave some customization options to the users so that they can decide when to insert line breaks.

For instance:

```lisp
(export '*one-element-per-line*)
(defvar *one-element-per-line* nil
"If non-nil, print one element per line in sequence types.")

(defun maybe-newline (stream)
(when *one-element-per-line*
(write-char #\newline stream)))

(defmethod serialize-sexp-internal ((object sequence) stream serialization-state)
"Like the original `serialize-sexp-internal' but uses `*one-element-per-line* to "
(flet ((proper-sequence (length)
(let ((id (set-known-object serialization-state object)))
(write-string "(:SEQUENCE " stream)
(prin1 id stream)
(write-string " :CLASS " stream)
(print-symbol (etypecase object (list 'list) (vector 'vector)) stream)
(write-string " :SIZE " stream)
(prin1 length stream)
(unless (zerop length)
(write-string " :ELEMENTS (" stream)
(maybe-newline stream)
(map nil
#'(lambda (element)
(write-string " " stream)
(serialize-sexp-internal element stream serialization-state)
(maybe-newline stream))
object))
(write-string " ) )" stream)))
(improper-list ()
(let ((id (set-known-object serialization-state object)))
(write-string "(:CONS " stream)
(prin1 id stream)
(write-char #\Space stream)
(serialize-sexp-internal (car object) stream serialization-state)
(write-char #\Space stream)
(serialize-sexp-internal (cdr object) stream serialization-state)
(write-string " ) " stream))))
(let ((id (known-object-id serialization-state object)))
(if id
(progn
(write-string "(:REF . " stream)
(prin1 id stream)
(write-string ")" stream))
(multiple-value-bind (seq-type length) (sequence-type-and-length object)
(ecase seq-type
((:proper-sequence :proper-list) (proper-sequence length))
((:dotted-list :circular-list) (improper-list))))))))
```

The above function is like the original except for the `maybe-newline` calls.