Iterated Divisor Twist Definitions

Let m and n be positive integers. We say that m is a divisor twist of n if there exists integers 1 &lt; a &le; b such that n = a*b and m = (a - 1)*(b + 1) + 1. If m can be obtained from n by applying zero or more divisor twists to it, then m is a descendant of n. Note that every number is its own descendant.

For example, consider n = 16. We can choose a = 2 and b = 8, since 2*8 = 16. Then 

(a - 1)*(b + 1) + 1 = 1*9 + 1 = 10


which shows that 10 is a divisor twist of 16. With a = 2 and b = 5, we then see that 7 is a divisor twist of 10. Thus 7 is a descendant of 16.

The task

Given a positive integer n, compute the descendants of n, listed in increasing order, without duplicates.

Rules

You are not allowed to use built-in operations that compute the divisors of a number.

Both full programs and functions are accepted, and returning a collection datatype (like a set of some kind) is allowed, as long as it is sorted and duplicate-free. The lowest byte count wins, and standard loopholes are disallowed.

Test Cases

1 -&gt;  [1]
2 -&gt;  [2] (any prime number returns just itself)
4 -&gt;  [4]
16 -&gt; [7, 10, 16]
28 -&gt; [7, 10, 16, 25, 28]
51 -&gt; [37, 51]
60 -&gt; [7, 10, 11, 13, 15, 16, 17, 18, 23, 25, 28, 29, 30, 32, 43, 46, 49, 53, 55, 56, 60]
Python 2, 109 98 85 82 bytes
f=lambda n:sorted(set(sum(map(f,{n-x+n/x for x in range(2,n)if(n&lt;x*x)&gt;n%x}),[n])))

Since (a-1)*(b+1)+1 == a*b-(b-a) and b &gt;= a, descendants are always less than or equal to the original number. So we can just start with the initial number and keep generating strictly smaller descendants until there are none left.
The condition (n&lt;x*x)&gt;n%x checks two things in one - that n&lt;x*x and n%x == 0.
(Thanks to @xnor for taking 3 bytes off the base case)
Pyth, 32 bytes
LS{s+]]bmydm+-bk/bkf&gt;&lt;b*TT%bTr2b

Direct translation of the above, except for the fact that Pyth seems to choke when trying to sum (s) on an empty list.
This defines a function y which can be called by appending y&lt;number&gt; at the end, like so (try it online):
LS{s+]]bmydm+-bk/bkf&gt;&lt;b*TT%bTr2by60

CJam, 47 45 bytes
{{:X_,2&gt;{__*X&gt;X@%&gt;},{_X\/\-X+}%{F}%~}:F~]_&amp;$}

Also using the same method, with a few modifications. I wanted to try CJam for comparison, but unfortunately I'm much worse at CJam than I am at Pyth/Python, so there's probably a lot of room for improvement.
The above is a block (basically CJam's version of unnamed functions) that takes in an int and returns a list. You can test it like so (try it online):
{{:X_,2&gt;{__*X&gt;X@%&gt;},{_X\/\-X+}%{F}%~}:F~]_&amp;$}:G; 60 Gp