The technique of using an auxiliary input that affects intermediate values, but not the final result, is called blinding. The auxiliary input can be called a “blinding parameter” or some other variant that depends on how it's used in the calculation, for example “blinding factor” if it's used in a multiplication. When the blinding is done with bitwise operations, it's often called masking.
Blinding is a common technique to avoid side channel attacks in cryptographic computations. The blinding parameter is usually random, but not always — there are cases where deterministic blinding is useful (for example, a blinding factor derived deterministically from the private key and the message in a signature operation). Random blinding only helps if the side channel cannot reveal all the secret data in a single trace, but that's a common case.
(Note that I'm not good at attacks — what follows is from my experience as a defender, where experts come to me and say “hey, we found this side channel in your products” and I look for a way to eliminate this side channel.)
The blinding strategy proposed here does not look good to me. Reading the bits of an exponentiation is a very well-known side channel, and breaking the exponentiation with a large exponent into a variable series of multiplications does not eliminate this side channel. On many platforms, code running on the same machine can measure with reasonable accuracy the exponents in a single trace. Even on better isolated platforms (for example, a remote attack), by observing many traces, the adversary can learn the distribution of factors, and that is probably enough to reconstruct the exponent with a practically feasible number of traces.
In general, adding noise to a computation is only a limited defense against side channel attacks. It forces the adversary to observe more instances of the calculation, but that's only a good defense if the side channel is limited, so that a non-noisy computation needs significant time to attack and the noise causes the attack time to become impractical. Noise doesn't help if even a single instance of the calculation leaks secret information.
You're reinventing a well-known wheel, and yours is very square. I strongly urge you to browse the literature on attacks and implementations of exponentiation, and look at how existing cryptography libraries do it. The preferable way to avoid timing side channels is not randomization (making the timing dependent on a combination of the secret inputs and an auxiliary secret), but to have the timing of operations be completely independent of secret inputs.