Difficulty estimate: 70

There are two possible solutions: one that is more straightforward and standard (BFS), and one that is a bit shorter and easier to make mistakes on (Greedy).
The problem can be made harder by enforcing the greedy solution by increasing the number of points to e.g 1000x1000.

BFS Solution
============
The solution idea is based on the fact that very few segments are ever relevant to draw.
More specifically, let S be the set of lines defined by taking any two of the dots on the field.
Let P be the set of all intersections between two lines in S.
Then, any optimal solution can be drawn using only segments connecting two points in P.

To see this, assume that the optimal solution is the sequence of points p_1, ..., p_n.

If p_i is a dot, we can WLOG assume p_(i-1) is one too, otherwise the segment p_(i-2), p_(i-1) can be modified to stop at the last dot on the segment.
Such a dot exists, since if the segment did not visit any dot at all, we can remove the point p_(i-1) from the solution.

If p_i is not a dot, the segment (p_(i-1), p_i) must contain at least two dots.
Assume this is not the case. Clearly, the segment must contain at least one dot, or we can find a solution which requires one fewer segment.
Now, consider the segments (p_(i-2), p_(i-1)) and (p_i, p_(i+1)), both of which contains at least one dot.
We can rotate the segment (p_1, p_(i+1)) around the single dot on the segment, until it hits another point on one of those two segments.
Note that this rotation does not change the number of points which either of those two segments hits.
This means we can repeat this procedure for every segment containing only a single point, and get a solution where every segment contains at least two points.

This means that any segment we draw pass through at least two points, meaning its endpoints indeed lie in P.

After this insight, we can construct a graph of all points in P, where any two points have an edge with metadata on which points the segment between those points pass.
The problem is then a BFS over (point in P, #visited).

Note: the above proof is not entirely correct for the case where two consecutive segments are parallell.
This can happen if e.g. the first row is 
1 3 2 4
However, in these cases it should be clear that the segments will still only use endpoints from P.

S contains exactly 62 elements, and P contains exactly 693 elements (see the associated num_lines.py python3 program). The graph will then contain 693*16 vertices, each with 693 edges.
This means a BFS on 7,683,984 edges, well within a time limit of a few seconds.

Greedy solution
===============
We can use an important fact (that any segment pass through at least two dots) from the BFS solution to make a greedy solution.

The first segment we use pass through dot 1. Since it must pass through at least one more dot, the line defined by the segment must be the one passing through dots 1 and 2.
If this ray can be extended to hit more points, we should do so.

Otherwise, we have two cases. If we decide to stop the first segment at another dot, the problem can be solved recursively by renumbering the points.
In the other case, we wish to extend the segment a bit, in order to hit (at least) the two next points.
If the second case is possible, we always wish to make such a segment. If there is such a segment, the first case can at most add a single new point, and stop there.
But if we instead do the second case, we can also decide to stop at the same point as in the first case, resulting in a solution that is no worse.

This means that we can always choose the next segment greedily in a way that is also globally optimal.
Whenever we are to draw a new segment, we must check how many points we can connect with the current segment.
If we check K points, we will also connect K points, so this procedure is amortized linear in the number of points.
