WIP: nosync: Implement sync.Map.

This is a new type in Go 1.9.

Map is a concurrent map. It's supposed to be safe for multiple
goroutines to call a Map's methods concurrently.

For now, implement it as a simple wrapper around map[interface{}]interface{}.
Since GopherJS is not multithreaded, as long as context switches don't
happen within Map methods, this should be safe.

TODO: Verify this is actually safe/correct.

Fixes:

	$ gopherjs test --short reflect
	$GOROOT/src/encoding/json/encode.go:335:18: Map not declared by package nosync

nosync/map.go

@@ -0,0 +1,67 @@
+package nosync
+
+// Map is a concurrent map with amortized-constant-time loads, stores, and deletes.
+// It is safe for multiple goroutines to call a Map's methods concurrently.
+//
+// The zero Map is valid and empty.
+//
+// A Map must not be copied after first use.
+type Map struct {
+	m map[interface{}]interface{}
+}
+
+// Load returns the value stored in the map for a key, or nil if no
+// value is present.
+// The ok result indicates whether value was found in the map.
+func (m *Map) Load(key interface{}) (value interface{}, ok bool) {
+	value, ok = m.m[key]
+	return value, ok
+}
+
+// Store sets the value for a key.
+func (m *Map) Store(key, value interface{}) {
+	if m.m == nil {
+		m.m = make(map[interface{}]interface{})
+	}
+	m.m[key] = value
+}
+
+// LoadOrStore returns the existing value for the key if present.
+// Otherwise, it stores and returns the given value.
+// The loaded result is true if the value was loaded, false if stored.
+func (m *Map) LoadOrStore(key, value interface{}) (actual interface{}, loaded bool) {
+	if value, ok := m.m[key]; ok {
+		return value, true
+	}
+	if m.m == nil {
+		m.m = make(map[interface{}]interface{})
+	}
+	m.m[key] = value
+	return value, false
+}
+
+// Delete deletes the value for a key.
+func (m *Map) Delete(key interface{}) {
+	if m.m == nil {
+		return
+	}
+	delete(m.m, key)
+}
+
+// Range calls f sequentially for each key and value present in the map.
+// If f returns false, range stops the iteration.
+//
+// Range does not necessarily correspond to any consistent snapshot of the Map's
+// contents: no key will be visited more than once, but if the value for any key
+// is stored or deleted concurrently, Range may reflect any mapping for that key
+// from any point during the Range call.
+//
+// Range may be O(N) with the number of elements in the map even if f returns
+// false after a constant number of calls.
+func (m *Map) Range(f func(key, value interface{}) bool) {
+	for k, v := range m.m {
+		if !f(k, v) {
+			break
+		}
+	}
+}