override SS pin and reduce bus glitches

It's very easy to use your own pin without this fix, but the code will always set A2 to an OUTPUT and set it HIGH even if you don't want it to.  Added a constructor to SPI Class to allow for overriding the SS pin.  If not defined, code will use A2 as usual.  If defined, code will use new pin.

Also found that the bus was glitching when changing ``SPI.setClockDivider(); SPI.setBitOrder(); or  SPI.setDataMode();`` after SPI has been enabled.  Simply removing the disabling/enabling of the SPE bit during ``SPI.setClockDivider();`` and ``SPI.setBitOrder();`` allows them to be changed on the fly without a glitch.  Due to the nature of how ``SPI.setDataMode();`` changes the way the bus works, it cannot be changed without disabling the SPE bit first (without consequences).

Here is some test code that iterates through the different modes.  Note only the first 4 tests do not glitch the bus, while the remaining ones involving DataMode do still glitch the bus.  This is unavoidable.

```cpp
#include <application.h>

bool s = true;
uint8_t test = 1;

void setup() {
  SPI.setClockDivider(SPI_CLOCK_DIV16);
  SPI.setBitOrder(MSBFIRST);
  SPI.setDataMode(SPI_MODE0);
  SPI.begin(A0); // A2 is not affected anymore
  pinMode(D7,OUTPUT);
}

void loop() {
  if(s) {
    switch(test) {
    case 1:
      SPI.setClockDivider(SPI_CLOCK_DIV16); // #2 fixed, #4 broke
      break;
    case 3:
      SPI.setBitOrder(MSBFIRST); // #6 fixed, #8 broke
      break;
    case 5:
      SPI.setDataMode(SPI_MODE0); // #11 unavoidable glitch
      // the worst glitch is when you set MODE0 over and over, because it pulses the SCLK
      break;
    case 7:
      SPI.setDataMode(SPI_MODE1); // #10 unavoidable glitch
      break;
    case 9:
      SPI.setDataMode(SPI_MODE2); // unavoidable glitch
      break;
    case 11:
      SPI.setDataMode(SPI_MODE3); // unavoidable glitch
      break;
    case 13:
      SPI.setDataMode(SPI_MODE0); // cycle MODE0, 1, 2, 3 in sequence
      break;
    case 15:
      SPI.setDataMode(SPI_MODE2); // ...
      break;
    }
  }
  else {
    switch(test) {
    case 2:
      SPI.setClockDivider(SPI_CLOCK_DIV8); // #3 fixed, #5 broke
      break;
    case 4:
      SPI.setBitOrder(LSBFIRST); // #7 fixed, #9 broke
      break;
    case 6:
      SPI.setDataMode(SPI_MODE0); // #11 unavoidable glitch
      // The worst glitch is when you set MODE0 over and over, because it pulses the SCLK
      break;
    case 8:
      SPI.setDataMode(SPI_MODE1); // #10 unavoidable glitch
      break;
    case 10:
      SPI.setDataMode(SPI_MODE2); // unavoidable glitch
      break;
    case 12:
      SPI.setDataMode(SPI_MODE3); // unavoidable glitch
      break;
    case 14:
      SPI.setDataMode(SPI_MODE1); // ...
      break;
    case 16:
      SPI.setDataMode(SPI_MODE3); // ...
      break;
    }
  }

  digitalWrite(A0, LOW);
  SPI.transfer(0xCC);
  digitalWrite(A0, HIGH);

  digitalWrite(D7,s);
  s = !s;
  test++;
  if(test > 16) test = 1;
  delay(1000);
}
```

#'s in the comments refer to the number of some scope plots found here: http://d.pr/f/GHHI

Signed the CLA form already ;-)