How can I detect lost of precision due to rounding in both floating point addition and multiplication?

Floating-point exceptions may help you here.

C support varies by implementation (compiler) but see GCC here: https://www.gnu.org/software/libc/manual/html_node/FP-Exceptions.html

Python support is documented here: https://docs.python.org/2/library/fpectl.html

I’ve only used these features a few times, and then only with the Intel compiler (https://software.intel.com/content/www/us/en/develop/documentation/cpp-compiler-developer-guide-and-reference/top/compiler-reference/compiler-options/compiler-option-details/floating-point-options/fp-trap-qfp-trap.html ), but in that case, I was able to trap truncation and other non-fatal errors (fatal would be dividing by zero, for example).

Normally one does not try to detect loss of precision algorithmically, but rather analyzes and modifies algorithms to assess how they are affected by it.

For instance, in your first example you would run a (forward) error analysis and figure out that the summation error is bounded by $3 cdot 10^{10} mathsf{u}$, where $mathsf{u}$ is machine precision, or you would show that the summation is backward stable so the summation has not done significantly more damage than storing that $10^{10}$ in a Float32 did in the first place.