Wolfram Language (Mathematica), 78 76 ... 51 49 bytes

1∣##&&#0[##,]~Do~{,2,-#/-##2/. 1:>Print@{##2}}&

Try it online!

Prints the list of decompositions.

Jelly, 14 bytes

ḊœċRẎḍƝẠ×P=¥ʋƇ

Try it online!

How it works

ḊœċRẎḍƝẠ×P=¥ʋƇ - Main link. Takes n on the left
Ḋ              - Dequeue; Yield [2, 3, ..., n]
   R           - Range, Yield [1, 2, ..., n]
 œċ            - For each integer, 1 ≤ i ≤ n, yield combinations with
                  replacement of length i from the dequeued range
    Ẏ          - Tighten into a single list of lists
            ʋƇ - Keep those for which the following is true:
        ×  ¥   -   Both of the following are true:
      Ɲ        -     Over overlapping pairs:
     ḍ         -       Is the left divisible by the right?
       Ạ       -     Is all true?
        ×      -   And:
         P     -     The product
          =    -     Equals n?

Japt, 22 19 bytes

ÆâÃcÅà â f@¶XcXäv)×

Try it

ÆâÃcÅà â f@¶XcXäv)×     :Implicit input of integer U
Æ                       :Map the range [0,U)
 â                      :  Divisors of U
  Ã                     :End map
   c                    :Flatten after
    Å                   :  Slicing the first element off each
     à                  :Combinations
       â                :Deduplicate
         f              :Filter by
          @             :Passing each X through the following function
           ¶            :  Test U for equality with
            Xc          :  Concatenate to X
              Xä        :    Consecutive pairs of X
                v       :    Reduced by testing divisibility
                 )      :  End concat
                  ×     :  Reduce by multiplication

Husk, ¹⁸ 15 bytes

fΛ¦ufo=¹ΠṖmΠtṖp

Try it online!

Similar to Grimmy's 05AB1E answer.

-3 bytes from Zgarb.

JavaScript, 115 bytes

f=(n,a=[],i=1)=>{for(;i++<n;)n%i||(a=a.concat(f(n/i).filter(e=>!(e[0]%i)).map(e=>[i].concat(e))));return n>1?a:[a]}

I will write an explanation later

Haskell, 66 62 60 bytes

f n=[n|n>1]:[k:l:m|k<-[2..n],l:m<-f$div n k,mod(gcd n l)k<1]

Try it online!

Jelly, 17 bytes

ÆfŒ!Œb€ẎP€€QḍƝẠ$Ƈ

Try it online!

JavaScript (V8),  73  70 bytes

Prints the tuples in descending order \$(k_m,k_{m-1},...,k_1)\$.

f=(n,d=2,a=[])=>n>1?d>n||f(n,d+1,a,d%a[0]||f(n/d,d,[d,...a])):print(a)

Try it online!

Commented

f = (             // f is a recursive function taking:
  n,              //   n   = input
  d = 2,          //   d   = current divisor
  a = []          //   a[] = list of divisors
) =>              //
  n > 1 ?         // if n is greater than 1:
    d > n ||      //   unless d is greater than n,
    f(            //   do a recursive call with:
      n,          //     -> n unchanged
      d + 1,      //     -> d + 1
      a,          //     -> a[] unchanged
      d % a[0] || //     unless the previous divisor does not divide the current one,
      f(          //     do another recursive call with:
        n / d,    //       -> n / d
        d,        //       -> d unchanged
        [d, ...a] //       -> d preprended to a[]
      )           //     end of inner recursive call
    )             //   end of outer recursive call
  :               // else:
    print(a)      //   this is a valid list of divisors: print it

05AB1E, 13 bytes

Òœ€.œP€`êʒüÖP

Try it online!

Ò                      # prime factorization of the input
 œ€.œ                  # all partitions
     P                 # product of each sublist
      €`               # flatten
        ê              # sorted uniquified
         ʒ             # filter by:
          üÖ           #  pairwise divisible-by (yields list of 0s or 1s)
            P          #  product (will be 1 iff the list is all 1s)

05AB1E, 17 15 14 bytes

ѦIиæʒPQ}êʒüÖP

Very slow for larger test cases.

-1 byte thanks to @Grimy.

Try it online.

Explanation:

Ñ               # Get all divisors of the (implicit) input-integer
 ¦              # Remove the first value (the 1)
  Iи            # Repeat this list (flattened) the input amount of times
                #  i.e. with input 4 we now have [2,4,2,4,2,4,2,4]
    æ           # Take the powerset of this list
     ʒ  }       # Filter it by:
      PQ        #  Where the product is equal to the (implicit) input
         ê      # Then sort and uniquify the filtered lists
          ʒ     # And filter it further by:
           ü    #  Loop over each overlapping pair of values
            Ö   #   And check if the first value is divisible by the second value
             P  #  Check if this is truthy for all pairs
              
                # (after which the result is output implicitly)