I was wondering what would happen if you were to add an adjustment (contrast, hue, color balance, etc.) in Photoshop/Lightroom/etc., export, then reopen to do the very opposite, and repeat the same process hundreds or thousands of times?
That depends on what the adjustment is. More specifically, it depends on whether making the adjustment and exporting results in the loss of any information, and also whether do the very opposite is an exact inverse operation or not.
For example, let's say that the operation in question is increasing the brightness, and that you're not increasing the brightness so much that any pixels get clipped, that reducing the brightness by the same amount really is exactly the opposite operation, and that you're exporting to a format that doesn't lose information (PNG, for example). In that case, you can increase and decrease the brightness for as many cycles as you like: the inverse operation returns you to exactly the same state as the original image, so the net effect of each increase/decrease cycle is zero change in the image. But, if you increase the brightness enough that some of the pixels (or even just one pixel) exceed their maximum allowable value, then you will have lost information and there's no way that the inverse operation can restore the original state. Repeating that kind of data loss thousands of times will result in a noticeable degradation of the image.
And on the very last time, you try your best to adjust the picture back to its original adjustment.
If you've truly lost information, there's no way to get it back. In the example above, you can reduce the brightness all you want, but that won't restore the original values of the clipped pixels.
Would the final export look different than the original? And if so, why would that be?
It would, but whether the difference is noticeable depends on how much information is lost. Were lots of pixels clipped? Then you'd see a loss of detail in the highlights, for example. I don't want to sound repetitive, but the reason why is, again, that information in the original image was thrown away.
Now, all that said, the folks who write image editing programs are well aware of these kinds of problems. It's for exactly this reason that most good photo processing software stores the original photo and records the changes you make to the image separately. You can increase and decrease the brightness on a photo all day long, and when you set it back to it's original value you'll be looking at the original image, whether or not brightening caused clipping, because those changes never changed the original. When you export and then import the image, though, you're creating a new and potentially different image, so the software won't be able to use the original image to get back to the original data.
I think the most important aspect of your question, not explicitly stated, is: Which operations are likely to result in losing data? Unfortunately, that's hard to know for sure; in many cases, like the brightness case discussed above, the answer depends on the data more than the operation. And it's not always clipping to minimum or maximum values that causes a problem. Imagine that you decrease the contrast of an image to the point where the difference between two adjacent pixels drops to 0. You export the image and import it again, locking in that change, and now there's no memory of the fact that those pixels used to have different values, so restoring the contrast to its original value cannot restore the difference between those pixels, and information is lost even though no pixels were clipped.
The dirty secret of computing is that computers don't do floating point math with perfect precision. Without going into a lot of detail, a simple calculation like
127/31 will result in a very close approximation, but not an exact answer. For that reason, data is frequently lost when making calculations, and this kind of rounding error can accumulate over time. So, even operations that seem like they should have exact inverses aren't truly exact. For that reason, you should assume that all operations will result in some data loss.