Unfortunately the title is a slight misnomer, it should be
“Fast Intersection of Sorted Arrays Using SSE Instructions”.
That is, the algorithm described really only works on arrays
(sometimes also called vectors).

It does not work on linked lists (basically that is because the
SSE instructions work on arrays/vectors and not on linked
lists).  So it does not really work on the skip-lists (which are
basically multiple linked lists with different strides).

Skiplists are not going to give faster search times when you use doubly linked lists.

I think the easiest way to see this is to realise that skiplists are basically multiple linked lists and they behave a lot like ordinary ordered linked lists.  And just like ordinary linked lists do not gain in search time from the backward link, neither do skiplists.

If you are willing to use more memory to decrease the search time (the average search time) with

skiplists, you can simply use more pointers on the higher layers.  So instead of adding another link

on the next layer with 50% probability (so you have about 1/2 as many links on each layer than on

the layer below) you can add another link on the next layer with e.g. 60% probability.  There is a limit beyond which speed will actually become worse again (because you start to spend more time walking the layers downward than you save from not having to scan the nodes on each layer rightward).  Actually on a perfectly balanced skiplist (where the nodes on every layer are equidistant), probability 50% is optimal.  But on a skiplist that is not perfectly balanced a slightly higher probability is a little bit better (my handwaving argument is that you loose more on

skips that are longer than average than you win on the skips that are shorter than average).

The backward links can still be useful on a plain linked list.  Namely if you may receiver a pointer to a node from some other part of your program and need to remove that node from the linked list. Than a backward link will allow you to remove that node in constant time from the linked list. Without the backward link you will need to search for the node, which will take O(N) time.  On a skiplist the same holds, i.e. backward links will allow you to remove random access nodes in constant time.  But since searching for the node only takes O(log(N)) time, the gain is smaller.

Hope this helps to answer the question. If not please feel free to ask further questions.