That being so, the assigned goto is just an indirect jump through the variable.
But in actual fact, the assigned goto had to be given a list of statement numbers
No, it had not. The list was always an optional one. If not given, the GOTO was simply executed without any further check.
What purpose does the statement-label list serve?
It's a run time check for valid targets.
This is why literature often calls the variants as 'Unguarded' (without a list) or 'Guarded' (with a list) Assigned GOTO.
It's important to keep in mind that FORTRAN was missing next to all control structures we take for granted today. FORTRAN is the prototypical spaghetti code and Assigned GOTO was the way to create complex structures with jump targets hidden in variables.
Adding a list to check against was a way to make certain loop constructions spaghetti code manageable (kind of) as well as to catch pointer errors. Not really the best way for either, but these were the beginnings of HLL, one had to start somewhere.
Using assign basically turns an integer into a pointer and loads it with the address of the label, not its numeric value.
An Unguarded Assigned GOTO takes the pointer value of the integer and jumps. With a list added it checks if the Integer holds the address of any single label within the list and only jumps when it's among them.
Think of forming a loop with a various cases within, like a state machine. Remember, there was no switch/case like statement in FORTRAN, so it had to be done some other way. And assigned GOTO was the way to go. At the end of each state check the next state was loaded into an integer but control was returned (via unconditional GOTO) to the main loop, which picked the next data and switched accordingly.
All of this ends up with a vast number of targets. In addition storage, and thus variables, was limited, so variables get reused. Using a single variable (like IGO) for all/most Assigned GOTO in a program was quite common. So this variable might contain some value from outside the loop constructions one was in. Quite a good chance to ass programming errors ending up at a
GOTO IGO with a leftover target from some prior construct.
Being able to name a list of all (at the point) valid targets seemed like a good idea to catch that and make sure all works as intended.
At that point it's once again important that we talk about a time when everything was barely invented, machines were small and compilers straightforward without much ability or even chance for checking. Not to mention that FORTRAN was on purpose kept simple to have users adopt it. Maybe hard to believe, but scientists were hardcore Assembly users at that time. So many concepts were tried, some of them might look strange from today's orderly landscape.
In addition, FORTRAN, as simple as it may seem today, was considered by many users as bloat. So making it work as straightforward as possible, so users can imagine the Assembly code while writing FORTRAN, was mandatory. There is a very nice interview with Frances Allen talking about this time.
Now, in a perfect world it could end here, but the real world also included implementation specific effects. The FORTRAN description did leave up a few grey areas:
For one it didn't define if and how an integer used to hold an integer is prevented against being used as target, nor if and how one holding a target is protected against being used as integer.
Using a Guarded Assigned GOTO one way to protect against such errors, by checking the values against legal values.
Second, it wasn't stated what happens if the integer is holding a target that is not within the list. Some implementation simply dropped to the next statement, while others threw an exception ending the program - which might be the most safe way.
Well, and some ignored the list at all.
Spaghetti code, implementation dependant behaviour, added, changed or missing instructions - everything we love and hate about BASIC was already present in FORTRAN, but on a much worse level.
With the introduction of additional loop control (WHILE, EXIT, etc.) in many FORTRAN-77 compilers (aka FORTRAN-78) the use of Assigned GOTO as well as computed GOTO or alternate returns became obsolete and finally removed in FORTRAN-90.