Add a special syntax for index operators

This commit introduces a new syntax for index operators.
Six core parenthesis operator are added:
.(), .[], .{}, .{,}, .{,,}, .{,..,}.
The .{,}/.{,,}/.{,,,} operators are defined for compatibility with
the Bigarray syntax extension.
Each core index operator is available in a safe/unsafe and
access/assignement versions. For instance, .() is declined in
.() : safe index operator
.()! : unsafe index operator
.()<- : safe indexed assignment operator
.()!<- : unsafe indexed assignment operator
The general syntax for these index operators as implemented
in the parser is index_operator::= index_operator_core [!] [<-]
Simplify the use of custom .() and .[]

This commit modifies the parser to use the newly defined
.() and .[] operators. It also moves the definition of the standard
.() and .[] operator for String/Bytes and Array to the pervasives
module.

Before this commit, expressions of the form array.(index) and
string.(index) where desugared to Array.get[_unsafe] array index
and Strinf.get[_unsafe] string index. The unsafe or unsafe version
are chosen depending on the presence of the "-unsafe" compiler option.
Such expression are now desugared to ( .()[!] ) array index and
( .[][!] ) string index respectively. The same desugar operation
is applied to array.(index) <- value which becomes
( .()[!]<- ) array index value.

In order to keep the standard semantic for the string and array
index operations, these new index operators are defined in
the pervasives module as their standard equivalents, e.g.
let .() = Array.get. Consequently, these modifications
should have no impact on existing code.

With these modifications, defining custom .() and .[] operators should
be easier, at the cost of losing access to the standard index operator
for either array or string.
Simplify the definition of custom .{} operators

This commits modify the Bigarray syntax extension in order to
facilitate the use of custom .{} operators. The compatibility with
the existing Bigarray syntax has been preserved as much as possible.
However, this commit will break code which use the Bigarray .{}
syntax without opening the Bigarray module first!

Like the previous commit, this commit modifies the parser
to desugar bigarray1.{index} to ( .{} ) bigarray1 index.
Following the bigarray syntax, the index operator used
in the desugaring changes if the index is a n-tuple:
1-tuple => .{}
2-tuple => .{,}
3-tuple => .{,,}
4 and more tuples => .{,..,}

The bigarray modules has been modified to use this new index
operators. Note that this means that these index operators
are not anymore accessible without opening the bigarray module.
( An option to avoid this problem would be to introduce a compiler
switch. )