Are there any garbage collectors that take into account paging?
As I recall, copy collectors are supposed to be paging friendly, as
the tracing by copying tends to improve the locality of pointer
references. This has a positive effect on the program (mutator) that
will cause less page faults when following links, and will also
improve the next collection cycle as tracing will also cause less page
faults. The tracing agenda (which pointers should be processed first) can have an impact on the effectiveness for improving data locality. This may be improved by mesuring statistics on the number of access to different pointers in different types of cells.

Now, if you consider a tracing collector in general, you must usually
maintain a structure that keeps track of the pointers that have not
been traced yet. It may be possible to organize this structure so that
all waiting pointers pointing in the same page will be kept together
(though that may take more space, in some cases, depending on the
available techniques to keep the list of such pointers).  A possible
policy is then to always trace first the largest set of waiting
pointers pointing to the same page, when there is no waiting pointer left to the pages in memory.

Regarding the question in the third paragraph, that was added after I answered, copy
collection is again an answer. The OS may reduce the number of
allocated physical pages at collection time, since the pages are completely
freed. With a mark and sweep collector, the event of a full page
beeing free is probably much rarer, thus not worth a specific
machanism to be taken into account.

This kind of ideas is natural, and is probably described in some of the
papers. But I do not recall it off hand. I think the early papers on Lisp GC contain some of these ideas (such as: should car or cdr be followed first?).

The good news in this role of copy-collection is also that paging is
friendly to copy collection since it increases the available storage
space. Recall that the copy collector requires in principle twice as
much space as used for actual data storage. Now, the effect of paging depends also on the address
space of the machine, and the physical memory available. In older
computer, physical memory was much less than available address space,
so that paging was really a space bonus, allowing policies such as
copy GC. Even when physical space is as big as the address space,
one might want to share it, so that the process using a GC would have
less address space without paging (see paging). These remarks are somewhat superseeded by the use of generational collectors. They generally use copy collection for the young generation precisely because of these qualities, and because the young generation is mostly short lived.

Then you have all the interactions of generational GC with the cache
system, that has been discussed in a previous question: Are generational garbage collectors inherently cache-friendly?

For more information on these issue, I would search the web with, for example, the keywords garbage collection and locality.