Hi Ed,
I found that the player to move first will lose in the 2x3 game, 
regardless of whether players are "obliged" to complete squares 
when they're able to.  With a corner square of value 2, player A
will lose by 3 squares.  With a corner square of value -2, player A
will lose by 1 square.

Ok, here's what I've found:

box = 2: player 2 will win, regardless of the first 3 moves

box = -2: If players have to make boxes when they are able to, then
there are only 3 combinations of opening moves that will result in a
victory for the first player (if optimal play is used after the first
two moves).  The first two moves must be two of the three edges shown 
here:

 +  +  +  +
  -2|
 +  +--+  +
    |
 +  +  +  +

There is also a unique situation that happens when these are the opening
two moves:

 +  +  +  +
  -2
 +  +  +  +
          |
 +  +  +--+

In this situation, player one will lose by three boxes if optimal play
is
used from this point forward (in all other combinations of first two
moves, 
player one loses by 1 box).



If players don't have to make boxes when they are able to (in the -2
game), 
then there are 38 combinations of opening moves that allow the first
player 
to win.


#include <stdio.h>

#define SPECIAL_BOX (2)
#define FORCE

int result[131072];

void process(int j, int& best, int prev_score=0)
{
  // All positions filled.
  if(j==0x1ffff) { if(prev_score > best) best=prev_score; return; } 

  int sector[6]; 
  int score;
#ifdef FORCE
  bool force = false;

  sector[0] = j&0x609;
  sector[1] = j&0xc12;
  sector[2] = j&0x1824;
  sector[3] = j&0x6048;
  sector[4] = j&0xc090;
  sector[5] = j&0x18120;
  if((sector[0]==0x608 || sector[0]==0x601 || sector[0]==0x409 || 
sector[0]==0x209) ||
     (sector[1]==0xc10 || sector[1]==0xc02 || sector[1]==0x812 || 
sector[1]==0x412) ||
     (sector[2]==0x1820 || sector[2]==0x1804 || sector[2]==0x1024 || 
sector[2]==0x824) ||
     (sector[3]==0x6040 || sector[3]==0x6008 || sector[3]==0x2048 || 
sector[3]==0x4048) ||
     (sector[4]==0xc080 || sector[4]==0xc010 || sector[4]==0x8090 || 
sector[4]==0x4090) ||
     (sector[5]==0x18100 || sector[5]==0x18020 || sector[5]==0x10120 || 
sector[5]==0x8120))
    force = true;
#endif

  for(int x=0; x<17; ++x) {
    if(j&(1<<x)) continue;

    score = 0;
    if(x == 0 && (j&(0x608))==0x608) score += SPECIAL_BOX;
    else if(x == 1 && (j&(0xc10))==0xc10) score += 1;
    else if(x == 2 && (j&(0x1820))==0x1820) score += 1;
    else if(x == 3) {
      if((j&(0x601))==0x601) score += SPECIAL_BOX;
      if((j&(0x6040))==0x6040) score += 1;
    }
    else if(x == 4) {
      if((j&(0xc02))==0xc02) score += 1;
      if((j&(0xc080))==0xc080) score += 1;
    }
    else if(x == 5) {
      if((j&(0x1804))==0x1804) score += 1;
      if((j&(0x18100))==0x18100) score += 1;
    }
    else if(x == 6 && (j&(0x6008))==0x6008) score += 1;
    else if(x == 7 && (j&(0xc010))==0xc010) score += 1;
    else if(x == 8 && (j&(0x18020))==0x18020) score += 1;
    else if(x == 9 && (j&(0x409))==0x409) score += SPECIAL_BOX;
    else if(x == 10) {
      if((j&(0x812))==0x812) score += 1;
      if((j&(0x209))==0x209) score += SPECIAL_BOX;
    }
    else if(x == 11) {
      if((j&(0x1024))==0x1024) score += 1;
      if((j&(0x412))==0x412) score += 1;
    }
    else if(x == 12 && (j&(0x824))==0x824) score += 1;
    else if(x == 13 && (j&(0x4048))==0x4048) score += 1;
    else if(x == 14) {
      if((j&(0x2048))==0x2048) score += 1;
      if((j&(0x8090))==0x8090) score += 1;
    }
    else if(x == 15) {
      if((j&(0x4090))==0x4090) score += 1;
      if((j&(0x10120))==0x10120) score += 1;
    }
    else if(x == 16 && (j&(0x8120))==0x8120) score += 1;

    if(score == 0) {
#ifdef FORCE
      if(force) continue;
#endif
      int the_score = prev_score-(result[j | (1<<x)]);
      if(the_score > best) best = the_score; 
    } 
    else {
      process(j|(1<<x), best, score+prev_score); 
    }
  }
}

int main()
{
  int best;

  for(int i=0; i<131072; ++i) result[i] = 0;
  int jcomp; 
  for(int i=16; i>=0; --i) {
  for(int j=0; j<131072; ++j) {
    jcomp=0;
    for(int k=0; k<17; ++k) { jcomp += (j&(1<<k)) ? 1 : 0; }
    if(jcomp != i) continue;

    best = -100;
    process(j, best, 0); 
    result[j] = best;
    //printf("result[0x%x] = %d\n", j, result[j]);
  }
  }

  printf("Expectation for player A is %d\n", result[0]);

  return 0;
}