This is a proof by contradiction. It assumes that there is a stable matching $S$ in which $A$ has a worse partner than in the stable matching $S^*$ produced by the Gale–Shapley algorithm, and derives a contradiction.
"$Z$ is not the worst valid partner for $A$": That such a pair exists follows from the assumption that $S^*$ is not "woman-pessimal" (never heard that term before :-). Here $A$ is a woman and $Z$ is a man.
The next sentence just explicates this: a "valid" partner of a woman here is one that can be her partner in a stable matching, so if $Z$ is not $A$'s worst valid partner, there is a stable matching $S$ in which $A$ is paired with a worse partner, say $Y$.
"$Z$ prefers $A$ to $B$": This is the clue. This follows from the man-optimality of $S^*$. (If you haven't proved this yet, you can find a proof of it in these slides, on the slide titled "Proof of Fact $3$".) Since $Z$ is married to $A$ in $S^*$, $S^*$ is man-optimal among all stable matchings, and both $S$ and $S^*$ are stable, $Z$ prefers $A$ to $B$.
"Thus, $A$-$Z$ is unstable in $S$.": This now follows because $Z$ prefers $A$ to $B$ and $A$ prefers $Z$ to $Y$.
First of all, yes, the loop invariant must be true before we start the loop, after each iteration, and after the loop completes.
See https://en.wikipedia.org/wiki/Loop_invariant, http://www.cs.miami.edu/home/burt/learning/Math120.1/Notes/LoopInvar.html, any of several other pages from university course notes that you'll find if you search for "loop invariant", or (presumably) your textbook.
In the most general sense, finding a loop invariant is about constructing
a mathematical proof, and there is not a simple set of instructions that will
give a good invariant whenever one exists. But if you have an inductive definition of the result of the algorithm, as you do here, your invariant might
also look like an inductive definition.
In this case you have that for all $i>1$, $F(i) = F(i-1) + F(i-2)$.
You also know the values of $F(0)$ and $F(1)$.
This suggests an algorithm in which before the first iteration of a loop,
you store the values $F(0)$ and $F(1)$ in two variables, $A$ and $B$, respectively, and you maintain the invariant that $A=F(k)$ and $B=F(k+1)$
where $k$ is the number of iterations of the loop that have completed.
You can prove that the invariant is maintained by showing that at the end of
each loop, the value in $A$ is the value that previously was in $B$,
and the value in $B$ is the previous value of $A+B$.
That is, if at the end of $k$ iterations you had $F(k)$ stored in $A$ and
$F(k+1)$ stored in $B$, at the end of the next iteration
(that is, after $k+1$ iterations) you will have $F(k+1)$ stored in $A$
and $F(k+2) = F(k+1) + F(k)$ stored in $B$.
My $A$ and $B$ look suspiciously like your r and l, respectively.
But note that in the algorithm I described, $B$ will store $F(n)$ after only
$n-1$ iterations, while your algorithm is written to do $n$ iterations,
and to return the larger number at the end of the $n$th iteration.
Your algorithm resolves this by doing an extra iteration at the beginning,
that is, it starts by setting l to $F(0)$ and r to $F(-1)$,
respectively, where $F(-1)=1$ in order that $F(1) = F(0) + F(-1)$.
So after $k$ iterations, where $k\geq 0$,
your algorithm always has $F(k-1)$ stored in r and $F(k)$ stored in l.
Alternatively, rather than defining $F(-1) = 1$, you can write a special
case into your loop invariant for the case when you have completed $0$ iterations. That is what your proposed invariant does, which is fine.
One of the potential difficulties of writing loop invariants is notational.
The invariant as I stated it depends on knowing how many iterations of the
loop have been completed. You have a variable i whose value during each
loop is clearly defined, but whose values at the beginning and end of each loop are not clear to me. At the end of the first loop, does i store the value $0$
or the value $1$? You should have a clearly defined convention for some
kind of variable associated with a loop control such as for i in [0,n),
with clearly-defined values of this variable before the first iteration
of the loop and at the end of each iteration of the loop.
Your notes or textbook should have established a convention for how you
construct such a variable for such a loop.
Without a clearly established convention, I'm not sure whether l at the
end of the last iteration is $f_n$ (which it is if $i$ in your invariant has
the value $k-1$ at the end of $k$ iterations)
or $f_{n+1}$ (which is what you get if $i$ denotes the number of iterations
that have been completed).
EDIT: "How I would have done it," not necessarily how you should do it:
If I were writing this for a formal methods course (or possibly even
in an ordinary program), I probably would have started by laying out the
base cases in code like this (using = for an equality test, not assignment):
if n=0
return 0
else if n=1
return 1
else if n>1
... do loop ...
return result
Note that the return value is undefined if $n<0$. For $n>1$,
the loop would do $n-1$ iterations of the $A,B$ algorithm I described above,
and the result would be the last value of $B$.
I might then notice that the outcomes would be the same if I wrote
if n=0
return 0
else if n>0
... do loop ...
return result
That is, one of the "if" conditions was superfluous. But I cannot get rid of
the special handling of the case $n=0$ with the loop as written,
because the loop depends on doing $n-1$ iterations to produce $F(0)$,
and you can't do $-1$ iterations of a loop.
Best Answer
We want to show that at any point in the algorithm, if it's true that $m$ has crossed off $w$'s name from his list at some point in the past, then $w$ has a suitor she likes better than $m$.
So the assumption at the beginning of the inductive step is simply describing the situation at the end of day $d+1$: we assume that, at this point in the algorithm, $w$'s name appears on $m$'s list with a line through it.
Then the two cases are considering different possibilities for when the crossing out occurred: