In the syndrome measurement circuit of a stabilizer code, I think you would consider that Pauli errors propagate through the CNOT gates. I don't understand why one usually considers the propagation of errors based only on the commutation relation between Pauli operators and CNOT, without taking into account the quantum state. For example, if a Z error occurs on the ancilla of the syndrome measurement circuit as in the left image below, it is considered equivalent to the right image due to the commutation relation between Pauli Z and CNOT, leaving two Z errors on the data qubits. Since the left and right circuits are equivalent, I can understand this thinking and this is the right thinking. However, on the other hand, if you consider based on the change of state as it is in the left circuit, since Pauli Z does not change $|0 \rangle$, there would be absolutely no effect of the Z error throughout the entire circuit. So, it can be considered that no error propagates to the data qubits. This thinking also seems right to me, and I can't see anything wrong with this thinking either. Why is this thinking wrong?
I am guessing you are studying how to build fault-tolerant circuits.
Your thinking is correct. This particular insight is usually left out of presentations, and the readers rediscover this on their own. I wrote a long blog post about this, that you can check out.
But, is it a useful insight? Perhaps, for some near-term experiments one might be able to exploit this idea to save a few qubits here and there when constructing a fault-tolerant circuit. However, ultimately, for long-term this is just a constant saving that one can ignore.
If a Z error occurs right after the reset, and you propagate it forward, it turns into a stabilizer of the code. Flipping a stabilizer has no effect on the code's state, so the non-error has propagated into a non-error, and everything is okay.
Another weird thing is that if you have an error between the first and second CNOT, it will propagate into what looks like three Z errors. But multiply by the stabilizer and it's only one error. So is it one error or three? It turns out that for all intents and purposes, e.g. in terms of its impact on code distance, it's only one error.
I think there's a key part of your thinking that may have gone slightly awry. The ancilla qubit starts in $|0\rangle$. Once you've performed some controlled-nots, it may no longer be in $|0\rangle$. Indeed, it's likely entangled with the data qubits. In which case, the $Z$ error that you've drawn on your circuit really does have an effect.
Of course, we could further contrive that it doesn't have an effect. Imagine that the bottom two data qubits are in some superposition of $|00\rangle$ and $|11\rangle$. That way, when your ancilla is hit by the $Z$ error, it's still in the $|0\rangle$ state, and you're thinking that the error has no effect on the data qubits, except that it's claimed there are two $Z$ errors! So, let's take this a bit more slowly. Remember that we're going to measure the ancilla at the end. So, that will either give us an answer $|0\rangle$ or $|1\rangle$. That with corresponds to the first and second data qubits being in a superposition of $|00\rangle/|11\rangle$ or $|01\rangle/|10\rangle$ respectively. In either case, $Z\otimes Z$ just gives a global phase, and so has had no effect. Hence, there is no discrepancy.