I don't want to spoil all the fun, in case anyone is still attempting  
this quiz, but here's my solution to four of the seven variations:

#!/usr/local/bin/ruby -w

# blackhole_chess
#
#  Created by James Edward Gray II on 2005-06-20.
#  Copyright 2005 Gray Productions. All rights reserved.

require "chess"

# An enhanced chess board for playing Blackhole Chess.
class BlackholeChess < Chess::Board
     #
     # A general purpose test to see if a _test_ square is between  
_start_ and
     # _finish_ squares, on a rank, file or diagonal.
     #
     def self.between?( start, finish, test )
         test_rank,   test_file   = test[1, 1].to_i,   test[0]
         start_rank,  start_file  = start[1, 1].to_i,  start[0]
         finish_rank, finish_file = finish[1, 1].to_i, finish[0]

         ( test_rank == start_rank and test_rank == finish_rank and
           test_file >= [start_file, finish_file].min and
           test_file <= [start_file, finish_file].max ) or
         ( test_file == start_file and test_file == finish_file and
           test_rank >= [start_rank, finish_rank].min and
           test_rank <= [start_rank, finish_rank].max ) or
         ( (start_file - finish_file).abs == (start_rank -  
finish_rank).abs and
           (start_file - test_file).abs == (start_rank -  
test_rank).abs and
           (test_file - finish_file).abs == (test_rank -  
finish_rank).abs and
           test_file >= [start_file, finish_file].min and
           test_file <= [start_file, finish_file].max and
           test_rank >= [start_rank, finish_rank].min and
           test_rank <= [start_rank, finish_rank].max )
     end

     # End the game if a King goes missing.
     def in_checkmate?( who = @turn )
         if find { |(s, pc)| pc and pc.color == who and pc.is_a?  
Chess::King }
             super
         else
             true
         end
     end

     # Eliminate any piece moving through the blackholes.
     def move( from_square, to_square, promote_to = nil )
         if self.class.between?(from_square, to_square, "d5") or
            self.class.between?(from_square, to_square, "f5")
             @squares[from_square] = nil
             next_turn
         else
             super
         end

         self
     end

     # Board display with two added blackholes.
     def to_s(  )
         super.sub( /^(5\s+\|(?:[^|]+\|){3})[^|]+\|([^|]+\|)[^|]+\|/,
                    "\\1 * |\\2 * |" )
     end
end

board = BlackholeChess.new

# insert my chess inteface code (see Summary) here, with a minor  
addition to spot
# a king that falls into a blackhole

__END__

#!/usr/local/bin/ruby -w

# fairy_chess
#
#  Created by James Edward Gray II on 2005-06-20.
#  Copyright 2005 Gray Productions. All rights reserved.

require "chess"

#
# The container for the behavior of a chess fairy.  Fairies are  
simply treated
# as both a Queen and a Knight.
#
class Fairy < Chess::Queen
     #
     # Returns all the capturing moves for a Fairy on the provided  
_board_
     # at the provided _square_ of the provided _color_.
     #
     def self.captures( board, square, color )
         captures =  Chess::Queen.captures(board, square, color)
         captures += Chess::Knight.captures(board, square, color)
         captures.sort
     end

     #
     # Returns all the non-capturing moves for a Fairy on the provided
     # _board_ at the provided _square_ of the provided _color_.
     #
     def self.moves( board, square, color )
         moves =  Chess::Queen.moves(board, square, color)
         moves += Chess::Knight.moves(board, square, color)
         moves.sort
     end
end

# Make the Chess::King aware of the Fairy.
class FairyAwareKing < Chess::King
     # Enhance in_check? to spot special Fairy moves.
     def self.in_check?( bd, sq, col )
         return true if Chess::Knight.captures(bd, sq, col).any? do | 
name|
             bd[name].is_a?(Fairy)
         end

         Chess::King.in_check?( bd, sq, col )
     end

     # Make this piece show up as a normal King.
     def to_s(  )
         if @color == :white then "K" else "k" end
     end
end

# An enhanced chess board for playing Fairy Chess.
class FairyChess < Chess::Board
     # Setup a normal board, then replace the queens with fairies.
     def setup(  )
         super

         @squares["d1"] = Fairy.new(self, "d1", :white)
         @squares["d8"] = Fairy.new(self, "d8", :black)
         @squares["e1"] = FairyAwareKing.new(self, "e1", :white)
         @squares["e8"] = FairyAwareKing.new(self, "e8", :black)
     end
end

board = FairyChess.new

# insert my chess inteface code (see Summary) here

__END__

#!/usr/local/bin/ruby -w

# fibonacci_chess
#
#  Created by James Edward Gray II on 2005-06-20.
#  Copyright 2005 Gray Productions. All rights reserved.

require "chess"

# An enhanced chess board for playing Fibonacci Chess.
class FibonacciBoard < Chess::Board
     # Setup chess board and initialize move count sequence.
     def initialize(  )
         super

         @fib1  = nil
         @fib2  = nil
         @count = 1
     end

     # Advance turn, as players complete moves in the Fibonacci  
sequence.
     def next_turn(  )
         if @fib1.nil?
             @fib1 = 1
         elsif @fib2.nil?
             @fib2 = 2
             next_turn if in_check?(@turn == :white ? :black : :white)
         elsif @count.zero? or in_check?(@turn  
== :white ? :black : :white)
             @fib1, @fib2 = @fib2, @fib1 + @fib2
             @count = @fib2 - 1
         else
             @count -= 1
             return
         end

         super
     end

     # Return a String description of the moves remaining.
     def moves_remaining(  )
         if @fib1.nil? or @fib2.nil? or @count.zero?
             "last move"
         else
             "#{@count + 1} moves"
         end
     end
end

board = FibonacciBoard.new

# insert my chess inteface code (see Summary) here

__END__

#!/usr/local/bin/ruby -w

# gun_chess
#
#  Created by James Edward Gray II on 2005-06-20.
#  Copyright 2005 Gray Productions. All rights reserved.

require "chess"

# An enhanced chess board for playing Gun Chess.
class GunChess < Chess::Board
     # Returns a numerical count of all the pieces on the board.
     def count_pieces(  )
         find_all { |(square, piece)| piece }.size
     end

     # Make standard chess moves, save that capturing pieces do not  
move.
     def move( from_square, to_square, promote_to = nil )
         old_count = count_pieces

         super    # normal chess move

         if count_pieces < old_count         # if it was a capture...
             move(to_square, from_square)    # move the piece back
             next_turn                       # fix the extra turn change
         end

         self
     end
end

board = GunChess.new

# insert my chess inteface code (see Summary) here, with a minor  
addition to
# promote pawns on moves only, never captures

__END__

You can download the complete files here:

http://rubyquiz.com/ruby_quiz_chess.zip

I was surprised that this wasn't harder.  I didn't tailor my library  
to the variations and I chose random variations to solve.  I expected  
the library would need enhancements for some, but that didn't seem to  
be the case, at least for these four variations.

James Edward Gray II