func hasKeyPath(crumb string, iv interface{}, key string, basket *map[string]bool) {
	switch iv.(type) {
	case map[string]interface{}:
		vv := iv.(map[string]interface{})
		if _, ok := vv[key]; ok {
			if crumb == "" {
				crumb = key
			} else {
				crumb += "." + key
			}
			(*basket)[crumb] = true
		}
		for k, v := range vv {
			var nbc string
			if crumb == "" {
				nbc = k
			} else {
				nbc = crumb + "." + k
			}
			hasKeyPath(nbc, v, key, basket)
		}
	case []interface{}:
		for _, v := range iv.([]interface{}) {
			hasKeyPath(crumb, v, key, basket)
		}
	}
}
hasKeyPath - if the map 'key' exists append it to KeyPath.path and increment KeyPath.depth
This is really just a breadcrumber that saves all trails that hit the prescribed 'key'.
package x2j
import (
	"strings"
)
func PathsForTag(doc string, key string) ([]string, error) {
	m, err := DocToMap(doc)
	if err != nil {
		return nil, err
	}
	ss := PathsForKey(m, key)
	return ss, nil
}
func PathForTagShortest(doc string, key string) (string, error) {
	m, err := DocToMap(doc)
	if err != nil {
		return "", err
	}
	s := PathForKeyShortest(m, key)
	return s, nil
}
func BytePathsForTag(doc []byte, key string) ([]string, error) {
	m, err := ByteDocToMap(doc)
	if err != nil {
		return nil, err
	}
	ss := PathsForKey(m, key)
	return ss, nil
}
func BytePathForTagShortest(doc []byte, key string) (string, error) {
	m, err := ByteDocToMap(doc)
	if err != nil {
		return "", err
	}
	s := PathForKeyShortest(m, key)
	return s, nil
}
func PathsForKey(m map[string]interface{}, key string) []string {
	breadbasket := make(map[string]bool,0)
	breadcrumb := ""
	hasKeyPath(breadcrumb, m, key, &breadbasket)
	if len(breadbasket) == 0 {
		return nil
	}
	res := make([]string,len(breadbasket))
	var i int
	for k,_ := range breadbasket {
		res[i] = k
		i++
	}
	return res
}
func PathForKeyShortest(m map[string]interface{}, key string) string {
	paths := PathsForKey(m,key)
	lp := len(paths)
	if lp == 0 {
		return ""
	}
	if lp == 1 {
		return paths[0]
	}
	shortest := paths[0]
	shortestLen := len(strings.Split(shortest,"."))
	for i := 1 ; i < len(paths) ; i++ {
		vlen := len(strings.Split(paths[i],"."))
		if vlen < shortestLen {
			shortest = paths[i]
			shortestLen = vlen
		}
	}
	return shortest
}