Extend sums and products functions
Your have the right ideas for implementing make-sum and make-product.  You may improve upon them in the following ways, in my opinion.

Within the two functions, you employ an inner function iter to partition numeric and non-numeric terms.  Traditionally, one uses the name iter to represent an iterative function; your definition, however, is most certainly recursive.  To make it truly iterative, one may use two accumulators--one for the sum of all numeric terms and the other for the rest of the terms.  Then one may return the cons of the two accumulators when the iteration terminates.

One may allow make-sum (and similarly make-product) to handle other sum-type objects in its terms list as well--simply test with sum?, then append its terms.

Finally, there are several cases that must be handled when iteration terminates: rest may be empty or it may contain one or more items; sum-numbers may be zero or non-zero.

Here's an implementation (naming scheme is slightly different from yours--in the iter function, terms is the list of remaining terms to be iterated upon, sum-numbers is the sum of all numeric terms seen so far, rest is a list of all non-numeric terms seen so far):

(define (make-sum . terms)
  (define (iter terms sum-numbers rest)
    (cond
      ((null? terms) (cons sum-numbers rest))
      ((=number? (car terms) 0) (iter (cdr terms) sum-numbers rest))
      ((number? (car terms)) (iter (cdr terms) (+ sum-numbers (car terms)) rest))
      ((sum? (car terms)) (iter (append (cdar terms) (cdr terms)) sum-numbers rest))
      (else (iter (cdr terms) sum-numbers (cons (car terms) rest)))))
  (let*
      ((result (iter terms 0 null))
       (sum-numbers (car result))
       (rest (cdr result)))
    (if (null? rest)
        sum-numbers
        (if (zero? sum-numbers)
            (if (null? (cdr rest))
                (car rest)
                (cons '+ rest))
            (cons '+ (cons sum-numbers rest))))))

(define (make-product . terms)
  (define (iter terms sum-numbers rest)
    (cond
      ((null? terms) (cons sum-numbers rest))
      ((=number? (car terms) 0) (cons 0 null))
      ((=number? (car terms) 1) (iter (cdr terms) sum-numbers rest))
      ((number? (car terms)) (iter (cdr terms) (* sum-numbers (car terms)) rest))
      ((product? (car terms)) (iter (append (cdar terms) (cdr terms)) sum-numbers rest))
      (else (iter (cdr terms) sum-numbers (cons (car terms) rest)))))
  (let*
      ((result (iter terms 1 null))
       (sum-numbers (car result))
       (rest (cdr result)))
    (if (null? rest)
        sum-numbers
        (if (zero? sum-numbers)
            (if (null? (cdr rest))
                (car rest)
                (cons '* rest))
            (cons '* (cons sum-numbers rest))))))


One may also simplify the definitions of augend and multiplicand by using make-sum and make-product respectively:

(define (augend s) (apply make-sum (cddr s)))

(define (multiplicand p) (apply make-product (cddr p)))


Note the similarities between make-sum and make-product.  It may be possible to factor out some code.  One may also use library functions such as partition (if available) to simplify the code.