Your subtraction circuit is not a two's complement subtraction but a simple unsigned integer subtraction circuit, without borrow. I mention this because there is a separate meaning for underflow/overflow when two-complement is involved. (I suppose this will be a later section you read?)
For zero and positive-only values (unsigned values) the subtraction operation is easily handled by inverting all of the bits of the subtrahend and adding 1. For addition (without carry), the carry in (CI) is set to zero. (I'm assuming that the ADD instruction's decoded value for the SUB wire is "0".) Then the addition proceeds. However, for subtraction, providing the "1" bit at the CI input provides that +1 addition that's needed.
With addition, the carry out is just the carry out. But with subtraction handled in the above way, the carry out has a different meaning because the subtraction was actually being carried out using addition (it's an adder, after all) with adjustments made to the subtrahend to make it work out. So the carry out being a "1" actually now means the subtraction completed without needing to borrow from the next higher word. That last XOR on the left, under your edition of subtraction, inverts that back to a "0" to show that there was no "borrow" needed. In this case, this means that if the carry status result after the operation is "0" there was no overflow for either ADD or SUB instruction operations.
This design works after a fashion, but it is less common to find in practice. Instead, the XOR on the left isn't present at all. In this case, a carry status=1 means different things for ADD and SUB. For ADD, it may mean the need to pass along that carry to a higher order word in a subsequent addition operation. For SUB, it means there was no borrow from the higher order word of the minuend. Similarly, a carry status=0 means there's no carry into a higher order word for ADD, but instead means there is a borrow from the higher order word of the minuend for SUB.
Typical designs find it easier to simply latch the carry-out as the carry status without the XOR. The reason for this is pretty simple. If the CI is "1" for a SUB instruction, then the subtract occurs without borrow. But if the CI is "0" for a SUB instruction, then the subtract occurs with borrow taking place. Using your indicated method, this gets a little more complex and adds logic prior to CI (as well as to CO.) The added logic of which is really unnecessary.
There's another advantage in handling it the way I've just described and not the way you've illustrated. A single SUB instruction is all that is required, instead of two SUB instructions (subtract and subtract with borrow.) A multi-word subtraction would start with setting the carry status=1 and then performing SUB. The SUB instruction would place the carry status value at CI and perform its operation. The CO output would be latched as the next carry status value. A subsequent, higher-order word subtract (if desired) would simply perform a following SUB of the higher-order words. The carry status would already be correct for placing at CI without added gates to make things work right. Saving instruction space leaves open room for other important instructions and does this without any real cost (except the need to start a multi-word subtraction by setting the carry to "1".)
That said, there are MCUs (older, in my recollection) which handle it the way you've described.