Create MinimaxCache class for caching game tree

Class MinimaxCache should have methods for the following:
 - #add_score hashes a spaces array to a score for that state
 - #get_score retrives the score for the input spaces array
 - #scored? returns true if the input spaces array has a score
Make #initialize instantiate a MinimaxCache object
Make #score add board spaces to cache with score

Minimax should populate the cache with board scores as they are
generated.
Make #score caches incomplete entries using symbol

When an array of board spaces cannot be scored, as limited by the depth
limit, the entry should be cached using the symbol :incomplete in place
of the score.
Make #scores use cached scores when available

When method #scores evaluates a given board state, the cache should be
checked first for an existing score. If one exists, the board needs no
further evaluation. If not, the board should continue with recursive
scoring.
Add method #incomplete? to check incomplete nodes

Nodes in the game tree whose branches have not been fully traversed and
evaluated should be hashed with a value of :incomplete.
Change :map attribute to accessor
Make #scores method preserve depth value

When encountering 'incomplete' nodes in the cache, further traversal
should not increase the current depth value. Doing this will allow the
depth value to be at the original value until unevaluated nodes are
evaluated, deepening the tree.
Fix bug by requiring 'minimax_cache'
Rearrange source for readability
Remove use of :incomplete to control depth limit
Move depth increment/decrement into #score

The statements for incrementing and decrementing the depth should be
placed within the conditional block depending on the current depth. This
will ensure that the depth is compared at least once before it has been
modified.
Add method #set_depth_limit to set the depth limit

The depth limit will depend on the state of the board. Size of the board
should inform how deep the recursion is allowed to traverse.
Make #choose_move set the depth limit on minimax
Remove 'depth_limit' argument from #initialize

The Minimax depth limit is set by the Player class using an instance of
this class. The #initialize method should set the depth limit to a
default value of zero.
Make #score cache scores using immutable keys

The key used to cache move scores should be immutable. Without this
protection, the cache becomes corrupted.

Currently, the board space array is used as the key. Since this changes
over time, only clones of this array should be cached.
Add method #score_moves to return numeric scores

Method #score_moves should call #scores to retrieve a map of space
scores. This map should be traversed to replace values of 'nil' with
zero. The goal is to separate "clean scores" from the cache. The cache
should handle non-numeric values internally, while score evaluation will
depend on exclusively-numeric scores.
Refactor #score
Switch Minimax method call #scores to #score_moves

ImpossibleComputer should only receive numeric scores, which are
returned by Minimax method #score_moves. Method #scores should be
limited to internal use by the Minimax class.

All relevant tests in Minimax spec should use the new method.
Make #score cache only winning/losing scores

If the depth limit has been reached before a winning condition has been
found, caching the returned zero score would prohibit later conditions
from being evaluated. Such values should not be cached.