Repeated fingerprinting after array updates
Any of the first three options you list are likely to be fine for what you want.

The CRC provides a good fingerprint (indeed, there's some theory to back that up, based on the theory of Carter-Wegman hashing, 2-universal hashes, etc.).

The Rabin fingerprint is also fine, and is essentially equivalent to the CRC (modulo small technical details that are unimportant).  $f^i(m_i) = m_i x^i \bmod p(x)$, which can be readily computed even for very large values of $i$ using fast modular exponentiation.

The Rabin-Karp hash is also fine, as long as you choose a good modulus $m$.  Don't pick a power of two; use a prime number.  Exponentiation is again fast if you use standard algorithms for fast modular exponentiation.  If possible, use a constant $a$ that is larger than the largest possible value of any single array element (single byte), i.e., larger than 256.  (Alternatively, it might be possible to pick $m$ to be a power of two if you also choose the constant $a$ to be a large random number modulo $m$; I haven't thought about that too carefully, so if that sounds attractive, please post a  separate question asking about that specific scenario.)

Buzhash is a little weaker than the other hash functions, though I suppose it's possible it might be good enough in practice.  Yes, Buzhash is susceptible to swapping of two values that are a multiple of 32 positions apart.  There might be ways to fix this, but given the large lookup tables required, that seems moot.  As you say, Buzhash requires a lookup table that maps from 8-bit values to 32-bit values (i.e., 256 entries, where each entry is a 32-bit word), so it sounds like Buzhash is not going to be feasible in your situation.