Add the beginnings of a for-expression solution to n-queens

A particularly suitable application area of for expressions are
combinatorial puzzles. An example of such a puzzle is the 8-queens
problem: Given a standard chess-board, place eight queens such that no
queen is in check from any other (a queen can check another piece if
they are on the same column, row, or diagonal). To find a solution to
this problem, it's actually simpler to generalize it to chess-boards of
arbitrary size. Hence, the problem is to place N queens on a chess-board
of N × N squares, where the size N is arbitrary. We’ll start numbering
cells at one, so the upper-left cell of an N × N board has coordinate
(1,1), and the lower-right cell has coordinate (N,N).

To solve the N-queens problem, note that you need to place a queen in
each row. So you could place queens in successive rows, each time
checking that a newly placed queen is not in check from any other queens
that have already been placed. In the course of this search, it might
arrive that a queen that needs to be placed in row k would be in check
in all fields of that row from queens in row 1 to k − 1. In that case,
you need to abort that part of the search in order to continue with a
different configuration of queens in columns 1 to k − 1.
An imperative solution to this problem would place queens one by one,
moving them around on the board. But it looks difficult to come up with
a scheme that really tries all possibilities.
A more functional approach represents a solution directly, as a value. A
solution consists of a list of coordinates, one for each queen placed on
the board.

Note, however, that a full solution can not be found in a single
step. It needs to be built up gradually, by occupying successive rows
with queens. This suggests a recursive algorithm. Assume you have
already generated all solutions of placing k queens on a board of size N
× N, where k is less than N. Each such solution can be presented by a
list of length k of coordinates (row, column), where both row and column
numbers range from 1 to N. It's convenient to treat these partial
solution lists as stacks, where the coordinates of the queen in row k
come first in the list, followed by the coordinates of the queen in row
k − 1, and so on. The bottom of the stack is the coordinate of the queen
placed in the first row of the board. All solutions together are
represented as a list of lists, with one element for each solution.

Now, to place the next queen in row k + 1, generate all possible exten-
sions of each previous solution by one more queen. This yields another
list of solution lists, this time of length k + 1. Continue the process
until you have obtained all solutions of the size of the chess-board N.
This algorithmic idea is embodied in function placeQueens here.

For now, we'll leave isSafe defined, but unimplemented.