Fix bug: masked property lost when slicing a masked table

This patch is fixing the following bug:
If a masked table is sliced, then the resulting table obtains the
masked numpy array, but not the self.masked attribute.
Thus, e.g. tab.filled() does not work any longer (it believes that the
table is not masked). This has further consequences, e.g. it makes it
very difficult to ever remove the mask from the table.
```
In [27]: tab = Table([[3,4],[5,6]], masked = True)

In [28]: tab1 = tab[[True, True]]

In [29]: tab.masked
Out[29]: True

In [30]: tab1.masked

In [31]: print tab1.masked
None

In [32]: tab.filled()
Out[32]:
<Table rows=2 names=('col0','col1')>
array([(3, 5), (4, 6)],
      dtype=[('col0', '<i8'), ('col1', '<i8')])

In [33]: tab1.filled()
Out[33]:
<Table rows=2 names=('col0','col1')>
masked_array(data = [(4, 6) (4, 6)],
             mask = [(False, False) (False, False)],
       fill_value = (999999, 999999),
            dtype = [('col0', '<i8'), ('col1', '<i8')])
```

The fix is fairly simple in principle:
In `_new_from_slice` the new instance of a table just needs to be created
with the correct masked value.

In order to test this, we just need to compare
table.masked and sliced_table.masked in the tests for slicing etc. .
That sounds simple, but in practice is complicated by the fast that indeed
three values were allowed for masked = [True, False, None].

Now why `None` at all? A table with `masked = None` behaves in any way like
a table with `masked = False`. However, all tables are created with
`masked = None`. Why was that? I am not really sure, but from looking at the
 code, this seems to be the reason: Setting `masked = True` raises an exception
if the table was masked before and setting `masked = False` raises an exception
is the table had `masked = False` before. So, the table had to be
initialzed with `masked = None` just to make sure that things don't break if
a user explicelty requests `masked = False`.
Hard to understand? I am not sure why the original implementation was this way.
So, I removed all notions of `masked = None`, now a tables is masked or it is
not masked.
[This change does not cause a single test to fail.]
Since masked cannot be set directly by the user anyway (it's a
property with no setter) I also removed the aformentioned Exception.
(Indeed, I am not sure if it ever was possible to get the Exception raised, since
the user cannot set `masked` directly anyway.)

Aside note:
According to the documentation, `Table.__init__` should accept a `mask` that
sets an inital mask, when really it takes only a `masked`, which determines
is a table will have a mask (and set all values of the mask to False).
I added documentation for the `masked` and commented out `mask` (since it
does not work).
I am not sure if `mask` might even be removed entirely or if this should be
fixed, but in any case that is beyond the scope of the current pull request.

@taldcroft : For I know that masked tables are close to your heart.