Pass read-write mode to keydir_get_int: permit read-write mode to always see latest mutations

Work around problems like this:

    1> C30 = binary_to_term(element(2,file:read_file("zzz.c30@develop@commit=dacf8f0630.bin"))).
    [[{set,{var,3},
           {call,bitcask_eqc,fork,
                 [[{init,{state,undefined,false,false,[]}},
                   {set,{not_var,2},{not_call,bitcask_eqc,bc_open,[false]}},
                   {set,{not_var,7},
                        {not_call,bitcask_eqc,fold,[{not_var,2}]}}]]}},
      {set,{var,6},{call,bitcask_eqc,bc_open,[true]}},
      {set,{var,7},{call,bitcask_eqc,put,[{var,6},1,<<>>]}},
      {set,{var,10},{call,bitcask_eqc,get,[{var,6},1]}}],
     {90598,47026,49786},
     [{events,[]}]]

This looks like a very simple test case.  It is.  Here's an interleaved
execution that shows a model failure.

    2> eqc:check(eqc:testing_time(15*60, bitcask_eqc:prop_pulse(local,false)), C30).
    Starting Quviq QuickCheck version 1.30.2
       (compiled at {{2013,11,18},{14,34,14}})
    Licence for Basho reserved until {{2013,11,23},{10,19,48}}
    Failed!
    [{set,{var,3},
          {call,bitcask_eqc,fork,
                [[{init,{state,undefined,false,false,[]}},
                  {set,{not_var,2},{not_call,bitcask_eqc,bc_open,[false]}},
                  {set,{not_var,7},{not_call,bitcask_eqc,fold,[{not_var,2}]}}]]}},
     {set,{var,6},{call,bitcask_eqc,bc_open,[true]}},
     {set,{var,7},{call,bitcask_eqc,put,[{var,6},1,<<>>]}},
     {set,{var,10},{call,bitcask_eqc,get,[{var,6},1]}}]
    {90598,47026,49786}

    State: {state,#Ref<0.0.0.520>,true,false,[<0.169.0>]}
    events: failed
    Events:
    [{0,23208,[]},
     {23208,23209,[{call,<0.161.0>,fork}]},
     {23209,23225,[]},
     {23225,23226,[{result,<0.161.0>,<0.169.0>}]},
     {23226,23351,[]},
     {23351,23352,[{call,<0.161.0>,{open,true}}]},
     {23352,28804,[]},
     {28804,28805,[{call,<0.169.0>,{open,false}}]},
     {28805,41666,[]},
     {41666,41667,[{result,<0.161.0>,#Ref<0.0.0.520>}]},
     {41667,41694,[]},
     {41694,41695,[{call,<0.161.0>,{put,#Ref<0.0.0.520>,1,<<>>}}]},
     {41695,48172,[]},
     {48172,48173,[{result,<0.169.0>,#Ref<0.0.0.545>}]},
     {48173,48209,[]},
     {48209,48210,[{call,<0.169.0>,{fold,#Ref<0.0.0.545>}}]},
     {48210,48413,[]},
     {48413,48414,[{result,<0.161.0>,ok}]},
     {48414,48445,[]},
     {48445,48446,[{call,<0.161.0>,{get,#Ref<0.0.0.520>,1}}]},
     {48446,48453,[]},
     {48453,48454,[{result,<0.161.0>,not_found}]},
     {48454,49098,[]},
     {49098,49099,[{result,<0.169.0>,[]}]},
     {49099,49123,[]},
     {49123,49124,[{call,<0.169.0>,{close,#Ref<0.0.0.545>}}]},
     {49124,49155,[]},
     {49155,49156,[{result,<0.169.0>,ok}]},
     {49156,infinity,[]}]
    Bad:
    [{0,48453,[]},{48453,infinity,[{bad,{get,1,[<<>>],not_found}}]}]
    false

At time 48453, we got a `get` result where we expected to find
a `<<>>` but instead got a `not_found`.  The `fold` operation is
interleaved at just the proper timing to trigger a keydir freezing,
which causes an unexpected result.

The patches in this commit add a read/write flag to the `keydir_get_int`
NIF function.  If the `keydir_get_int` being performed is by the one
process that has the bitcask open for read/write mode, then we should
ignore all snapshots and be able to get the latest-and-greatest mutation
of the keydir.  The diff is enlarged/cluttered by small patches to fix
up other test cases: to add the appropriate new argument where needed.