Error correcting code? - using RGB space with a lookup table
This is a bit of a &quot;I hope I understand your question right&quot; answer, but seeing I have to leave for the day:
Randomizing the LSBs of all the three color channels would obviously reduce the amount of information a single pixel could carry would reduce the amount of information carried in that color from 24 to 21 bits.
Picking one randomly and randomly varying that has an entropy $1+ \log_2 3$ bits, so you reduce the information contained in that pixel's color from 24 to ca 21.415 bit. This doesn't look like it seriously introduces any privacy there.
It will be impossible to find a 24-bit code that has a rate higher than 21.415/24 that can correct 3 bit errors, so, honestly, you usually simply wouldn't need to use error correction at all.
Still, I think they're doing that for a reason – probably it breaks an existing system of identification. There's no &quot;provable&quot; privacy to be won here, just an &quot;against a single implementation&quot; privacy.

Assuming the anti-aliasing blends linearly

Not the case, usually; you use low-pass filters that are more than a linear interpolation to get acceptably-looking edges.

How to create an ordering of points in 8bit RGB space, such that the minimum number of points are colinear without knowing the final total number of points?

Oh, that's a very interesting problem!
However, we do know from linear algebra how to find linearly independent vectors in a vectors space (e.g. simply choosing canonical base vectors that are all zero but for one entry, or taking a set of random vectors and doing Gram-Schmidt on them).
In this case, our vector space is 3-dimensional. In a three-dimensional space, you get exactly 3 bases in each orthogonal base system, soooo, that's three code points that are orthogonal only! That's very few.
Now, if you add two of these code points, you get another code point, which isn't colinear with any of the existing code points, and since 3-choose-2 is 3, you get three new code points, for a total of 6. You can also add up all three original bases and get one new. OK, so 7 code points.
You can iteratively repeat that, but you have to be careful: You will find multiple ways to calculate the same code point later on, or even multiples of that, and at some point, your elements' coordinates can get larger than your 8-bit integers can hold. But since essentially computers are fast, and the number of things you'll get will be still quite low, you can probably really just brute force your way out of this reasonably by going through all possible pairs of points you have, adding them, and checking that the result is not a multiple of any existing point.