The canonical linear interpolation/extrapolation function is
$$y = \frac{x_2 - x}{x_2 - x_1} y_1 + \frac{x - x_1}{x_2 - x_1} y_2 = \frac{(x_2 - x) y_1 + (x - x_1) y_2}{x_2 - x_1}$$
This is numerically stable, although you do need to do two multiplications, one division, and three subtractions and one addition. Use the right-side form, and you're golden, even if you have limited numerical precision.
If you evaluate \(y\) for many \(x\), it can be useful to regroup the values, into
$$y = \frac{x (y_2 - y_1) + x_2 y_1 - x_1 y_2}{x_2 - x_1} = \frac{ x U + V }{ W }, \left\lbrace\begin{aligned}
U &= y_2 - y_1 \\
V &= x_2 y_1 - x_1 y_2 \\
W &= x_2 - x_1 \\
\end{aligned}\right.$$
noting that if \(x_1, y_1, x_2, y_2\) are integers, then \(U, V, W\) are too. This is numerically stable, and you don't lose any precision doing this. Your temporaries do need the range to describe the products (magnitude of \(V\)), but no additional precision.
Bresenham's line algorithm simply tracks the error in \(y\) in reciprocal units of \(x_2 - x_1\), quite easily derived from above form. (That way, if the coordinates are all integers, the error is always an integer in those units too. When one realizes this, the entire Bresenham family of fast 2D raster drawing functions becomes very intuitively understandable.)
For unit interpolation using "phase" \(p\), (\(p = 0\) at \(x = x_1\), and \(p = 1\) at \(x = x_2\)), this becomes \(y = (1 - p) y_1 + p y_2\). Again, this is numerically stable, with exact values at \(p = 0\) and \(p = 1\), with largest rounding error somewhere near the middle. Even with floating point numbers and \(y_1\) and \(y_2\) wildly different in magnitude (so that you get "\(y_1 + y_2 = y_1\)" or "\(y_1 + y_2 = y_2\)" because of domain cancellation), the endpoints are exact, and the interpolated values are linear to within the precision available in the floating-point number type used. Very useful.
Not so with \(y = y_1 + p (y_2 - y_1)\), which utterly fails if \(\lvert y_1 \rvert \gg \lvert y_2 \rvert\), and is offset if \(\lvert y_1 \rvert \ll \lvert y_2 \rvert\) with floating-point numbers. It is horrifically numerically unstable, and should not be used with floating-point numbers. It will bite you eventually; it always does.
The traditional definition of a line in a Cartesian coordinate system is (now typos fixed):
$$y = A x + B, \quad A = \frac{y_2 - y_1}{x_2 - x_1}, \quad B = \frac{x_2 y_1 - x_1 y_2}{x_2 - x_1} = y_1 - x_1 A$$
and is the worst choice if using limited precision like floating-point numbers. Any rounding error in \(A\) means the slope is incorrect, and any rounding error in \(B\) shifts the entire line. In computer programs using floating-point numbers, this form often leads to surprising numerical errors due to the numerical instability and sensitivity to rounding errors. In 3D rendering, the "edge tearing" (flat surfaces meeting at a shared edge not closing up properly) is a very visible result of closely related numerical instability issues.
Apologies for the algebra gushing, but I just see too many developers get bitten by numerical instability. I know it doesn't matter, usually; except until it actually does and the errors become noticeable. Numerical stability is good, but often needs a small bit of extra work, as shown above.