It's not that FORTRAN required those particular instructions, but that they were the sort of instructions that existing FORTRANs tended to use.
At the time, calling conventions were somewhat unsettled, and different machines exhibited a fairly large variety of instructions to implement calls.
The link you gave cites the ostensible reason:
JSA, Jump and Save AC, stores the AC in word addressed by the
effective address. Then the left half of the AC is set to the
effective address and the right half of AC is set to the return PC.
Then the PC is set to one greater than the effective address. The JRA
instruction unwinds this call.
The advantage of this call is that a routine may have multiple entry
points (which is difficult to do with JSR) and it's easy to find (and
later to skip over) arguments that follow the calling instruction
(which is possible to do with PUSHJ, but not quite so convenient).
Among the disadvantages of this call is that it is non reentrant, and
it doesn't save flags.
So, if I've got this right, the subroutine expects a JSA with a specific AC. Once you've entered the subroutine at one of its several entry points, the old AC content is stored at that entry point, and (this is the crucial part) the entry point address and return address both are in the AC.
The return address being in the AC allows return without knowing the particular entry point (which is not possible if the link is stored at the entry point). And (but this is common to the case where the link is saved in the AC) you can retrieve the arguments that are inline after the call, a fairly common parameter-passing mechanism at the time.
The entry point address being in the AC allows two things: (1) automatic restore of the AC on return - not possible with a simple "save link in AC" instruction, (2) you can find the previous content of the AC, though off-hand I can't think of why you'd need that. Possibly for "alternate exits" through labels passed as arguments?
Point (1) could have been done with PUSHJ/POPJ, but stacks were not really in the FORTRAN mindset at the time. From this vantage point, it looks like the PDP-6 designers included one of everything.
Per the PDP-6 handbook, page 36:
There are three reasons for the JSA-JRA pair: to provide for subroutines with multiple entries;
to provide an easily-accessible referece for getting data; and to
prevent loss of information, making it possible to nest subroutines.