I'm very curious where this came up. In any case, the answer to the first question is yes, it does distinguish these trefoils; you found the minimal representatives.

Let $a_0,\dots,a_{N-1}$ be the roots of unity that are visited along the knot, in (cyclic) order. Suppose we have a minimal representative for some non-trivial knot. Then we cannot have $|a_k - a_{k+1}| = 1$ for any $k$, as otherwise we could replace this pair $a_k, a_{k+1}$ by a single root of unity (for $N-1$), adjusting the other roots of unity as appropriate. A little more subtly, we cannot have $|a_{k-1} - a_{k+1}| = 1$ either, as then we could again delete $a_k$ from the sequence to get a smaller representation. With these simple constraints, the smallest possible sequence for a non-trivial knot is the one you found for one of the trefoils with $N=7$. There are several possibilities for $N=8$, including the one you found for the other trefoil. I've included a very short Haskell program below that computes this. The possibilities for $N=8$ are $$ (2,7,5,3,1,6,4,0)\quad (2,5,7,3,1,6,4,0)\quad (3,6,1,4,7,2,5,0)\quad (2,6,4,1,7,3,5,0) $$ $$ (3,1,6,4,2,7,5,0)\quad (2,4,6,1,3,7,5,0)\quad (3,5,1,7,4,2,6,0)\quad (4,2,7,5,1,3,6,0) $$ $$ (3,1,5,7,2,4,6,0)\quad (5,3,1,6,4,2,7,0)\quad (2,4,6,1,3,5,7,0) $$

For the second question, I have never heard of this representation before.

Here is the code, for anyone interested.

 -- A (partial) circular stick representation is a list of integers,
 -- the order of the roots of unity to visit in order
 type CircStick = [Int]
 
 -- The next element ak after a partial representation a1, ..., a{k-1} 
 -- must satisfy
 --   (a) ak has not already been seen
 --   (b) |ak - a{k-1}| > 1
 --   (c) |ak - a{k-2}| > 1
 -- There are a few more "easy" constraint, eg the first and last entries
 -- cannot differ by one.  We do not impose those constraint here.
 nexts :: Int -> CircStick -> [Int]
 nexts n [] = [0]
 nexts n [a1] = filter (\a -> abs (a-a1) > 1) [0..n-1]
 nexts n (a1:a2:as) =
   filter (\a -> not (elem a as)) $
   filter (\a -> abs (a-a1) > 1) $
   filter (\a -> abs (a-a2) > 1) $
     [1..n-1]
     
 completions :: Int -> CircStick -> [CircStick]
 completions n as | length as >= n = [as]
 completions n as =
   concat [completions n (a:as) | a <- nexts n as]
   
 -- Impose final constraints:
 --    (a) Last entry cannot be 1
 --    (b) Take entry that is lexicographically less than its reverse
 --    (c) first and next-to-last entries cannot differ by one
 circSticks :: Int -> [CircStick]
 circSticks n = 
   filter (\as -> abs ((as!!0) - (as!!(n-2))) > 1) $
   filter (\as -> as < tail (reverse as)) $
   filter (\as -> head as /= 1) $
   (completions n [])