Define a new Features() method for Fs

Optional interfaces are becoming more important in rclone,
--track-renames and --backup-dir both rely on them.

Up to this point rclone has used interface upgrades to define optional
behaviour on Fs objects.  However when one Fs object wraps another it
is very difficult for this scheme to work accurately.  rclone has
relied on specific error messages being returned when the interface
isn't supported - this is unsatisfactory because it means you have to
call the interface to see whether it is supported.

This change enables accurate detection of optional interfaces by use
of a Features struct as returned by an obligatory Fs.Features()
method.  The Features struct contains flags and function pointers
which can be tested against nil to see whether they can be used.

As a result crypt and hubic can accurately reflect the capabilities of
the underlying Fs they are wrapping.

local/local.go

@@ -47,6 +47,7 @@ func init() {
 type Fs struct {
 	name        string              // the name of the remote
 	root        string              // The root directory (OS path)
+	features    *fs.Features        // optional features
 	dev         uint64              // device number of root node
 	precisionOk sync.Once           // Whether we need to read the precision
 	precision   time.Duration       // precision of local filesystem
@@ -78,6 +79,7 @@ func NewFs(name, root string) (fs.Fs, error) {
 		dev:    devUnset,
 	}
 	f.root = f.cleanPath(root)
+	f.features = (&fs.Features{CaseInsensitive: f.caseInsensitive()}).Fill(f)
 
 	// Check to see if this points to a file
 	fi, err := os.Lstat(f.root)
@@ -108,6 +110,21 @@ func (f *Fs) String() string {
 	return fmt.Sprintf("Local file system at %s", f.root)
 }
 
+// Features returns the optional features of this Fs
+func (f *Fs) Features() *fs.Features {
+	return f.features
+}
+
+// caseInsenstive returns whether the remote is case insensitive or not
+func (f *Fs) caseInsensitive() bool {
+	// FIXME not entirely accurate since you can have case
+	// sensitive Fses on darwin and case insenstive Fses on linux.
+	// Should probably check but that would involve creating a
+	// file in the remote to be most accurate which probably isn't
+	// desirable.
+	return runtime.GOOS == "windows" || runtime.GOOS == "darwin"
+}
+
 // newObject makes a half completed Object
 func (f *Fs) newObject(remote string) *Object {
 	dstPath := f.cleanPath(filepath.Join(f.root, remote))