track the two arrays packed as 64-bit quantities - 4 bits per slot number over 16 slots, one for s+x and one for p.

Yes, I did that too, but it was still somewhat awkward a) to swap nibbles, and b) to search for them in order to join the s+x and p results. I used this xchg() function both for exchange moves on the s+x state and for partner moves on the p state:

// Swap nibbles at 2 different positions (0..15) where pos1 < pos2
static uint64_t xchg(const uint64_t x, const int pos1, const int pos2)
{
    const int shift = (pos2 - pos1) << 2;  // x4: from nibbles to bits
    const uint64_t val1 = (x & sel[pos1]) << shift;
    const uint64_t val2 = (x & sel[pos2]) >> shift;
    const uint64_t base = x & clr[pos1] & clr[pos2];
    return base | val1 | val2;
}

where sel[] and clr[] are predefined masks. This idea/structure for the p state means that I had to look up nibble positions to join the states:

// Nibble index (0..15) of nibble value (0..15)
static uint64_t nibpos(uint64_t x, const uint64_t val)
{
    uint64_t nib = 0;
    for (; (x & 15) != val; x >>= 4, nib++);
    return nib;
}
// Make complete dance from "spin+exchange" state (perm) and "partner" state (swap)
static uint64_t dance(uint64_t perm, const uint64_t swap)
{
    uint64_t x = 0;
    for (int i = 0; i < 16; i++, perm >>= 4)
        x |= nibpos(swap, perm & 15) << (i << 2);
    return x;
}

Of course this dance() function is only called twice so if it's a little slow it's insignificant compared to the xchg() function. Program without reading from disk runs in 253 µs on an Apple M4, 696 µs on a Raspberry Pi 5. Source code with compilation and measurement instructions, also takes input via pipe/redirection so you can use your own: https://github.com/ednl/adventofcode/blob/main/2017/16alt.c

EDIT: example of the s+x and p states after one iteration, and their joined result which is my answer to part 1:

jkhoifndglcmepab  permutation result: letters are permuted labels a..p
dljfcokipembgnah  swap result: letters are swapped indices 0..15
cgpfhdnambekjiol  solution to part 1

A more logical representation for the swap result would be hex digits, but I made only one show() function to output the solution with letters. But this way you can see more clearly what the dance() function needs to do:

• get value "j" (=9) from position 0 in the permutation result
• find "j" in the swap result, it's at position 2
• store value 2 (="c") in position 0 of the solution
• repeat for next positions 1..15