Is there an explicit construction of this bijection?

Yes, there is! In fact, here's $(n-1)!$ of them!

I wish to thank user Phylliida for both the algorithm and the python psudocode below. The proof is my own (though I've found it hard to write in some standard notation...).

The idea is based on the $k=1$ case. For a set $A = \{a_1, \cdots, a_k \}$ we increase $a_1$ (modulo n) until it's no longer in $A,$ and put that element in $f(A).$ Now we take $a_2$ and increment it until it is no longer in $A$ or an element we've already put in $f(A),$ and declare that to be in $f(A).$ We carry on like this for all the $a_i,$ so that our output has the correct size.

For example, with the set $\{1,3,4,5,9\}$ mod $11,$ we would first increment $1$ up to $2$ and put this into our output, then we move $3$ to $6,$ passing over $4$ and $5$ because they are in the input set. We similarly move $4,5$ and $9$ to $7,8$ and $10$ respectively. Our output is thus $\{2,6,7,8, 10\}.$

It is clear that this will always give us a disjoint set from the input of the right size. However, it is not at all clear that this is well defined (does the order of the $a_i$ matter?) or that it is invertible. It turns out this algorithm is essentially its own inverse, so that if we phrase it with a bit of generality it will suffice to show it's well defined.

---

So, with more generality now. Fix an $n$-cycle $\pi,$ and a set $A$ as above. Define the multiset $A_1 = A \cup \pi A$ of size $2k.$ We then construct $A_2$ by applying $\pi$ to all but one of each duplicate element in $A_1.$ In general we have $$A_{i+1} = set(A_i) \cup \pi (A_i - set(A_i)) $$

where $set(U)$ denotes the set of elements in a multiset $U,$ multiset difference removes instances (ie, $(1,2,2) - (1,2) = (2)$), and the union is treated as a union of multisets. Note that $A_{i+1} = A_i$ when $A_i$ is a set, that we always have exactly $2k$ elements in $A_{i+1},$ and finally that after $k$ steps we must have an actual set instead of a multiset. So we define $$f_\pi(A) = A_k - A.$$

This is equivalent to the algorithm outlined above when $\pi = (1, \cdots, n).$ We're just incrementing each element (mod n) until they find an unused place. If two elements find the same place, then we leave one of them in the gap and continue incrementing the other.

Now, I claim the inverse to $f_{\pi}$ is $f_{\pi^{-1}}.$ This follows almost immediately if we return to our original presentation of the algorithm: Suppose $a_k$ is incremented to $\pi^j a_k.$ Then we must have $\pi^1 a_k, \pi^2 a_k, \cdots, \pi^{j-1} a_k \in f_\pi(A),$ which implies that $f_{\pi^{-1}}$ will return $\pi^j a_k$ to the first open spot, namely $a_k.$ After performing this move, we're in exactly the same state as $f_\pi$ would be before moving $a_k.$ $f_{\pi^{-1}}$ continues exactly undoing $f_\pi$ if we next consider wherever $a_{i}$ ended up in descending order.

As an example of the inverse direction, if we start with ${2, 6, 7, 8, 10}$ then we would first decrement $10$ to the first open place ($9$), then $8$ would be decreased past $7$ and $6$ down to $5.$ Similarly $6,7$ are moved to $3,4.$ Finally $2$ gets decreased down to $1.$ Note we've moved each number back to where it came from in the original setup.

---

I conclude with some python code for the bijection.

def rot(bits,inv):
 res = [x for x in bits]
 original = [x for x in bits]
 n = len(bits)
 for i in range(n)[::inv]:
  if original[i] == 1:
   for j in range(1,n+1)[::inv]:
    new = (i + j) % n
    if res[new] == 0 and original[new] == 0:
     res[new] = 1
     res[i] = 0
     break
 return res

res should be an array with a $1$ in the ith place if $i \in A.$ inv should be set to 1 to do the forward direction, -1 to invert. For example

rot([1,0,1,1,1,0,0,0,1,0,0], 1) = [0,1,0,0,0,1,1,1,0,1,0]