Given a positive integer $n$ you can always find a tuple $(k_1,k_2,...,k_m)$ of integers $k_i geqslant 2$ such that $k_1 cdot k_2 cdot ... cdot k_m = n$ and $$k_1 | k_2 text , k_2 | k_3 text , ldots text , k_m-1|k_m.$$
Here $a|b$ means $b$ is a multiple of $a$, say "a divides b". If $n>1$ all entries $k_i$ must be at least $2$. For $n=1$ we have no such factor and therefore we get an empty tuple.

In case you're curious where this comes from: This decomposition is known as invariant factor decomposition in number theory ant it is used in the classification of finitely generated
Abelian groups.

Challenge

Given $n$ output all such tuples $(k_1,k_2,...,k_m)$ for the given $n$ exactly once, in whatever order you like. The standard sequence output formats are allowed.

Examples

 1: () (empty tuple)
 2: (2)
 3: (3)
 4: (2,2), (4)
 5: (5)
 6: (6)
 7: (7)
 8: (2,2,2), (2,4), (8)
 9: (3,3), (9)
 10: (10)
 11: (11)
 12: (2,6), (12)
108: (2,54), (3,3,12), (3,6,6), (3,36), (6,18), (108)

Related: http://oeis.org/A000688, List all multiplicative partitions of n

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!

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)

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, 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)

Jelly, 17 bytes

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

Try it online!