batch of golangci-lint fixes in `atproto/*` (#1031)

This isn't everything, just a first pass. There were some real issues
with errors not getting wired through.

I'm kind of ambivalent about the pattern:

```go
defer func() {
_ = resp.Body.Close()
}()
```

but do want to make any non-defer error returns explicit.

.gitignore

···
 # Don't ignore this file itself, or other specific dotfiles
 !.gitignore
 !.github/
+!.golangci.yaml
 
 # Don't commit your (default location) creds
 bsky.auth

.golangci.yaml

···
+version: "2"
+
+issues:
+  max-issues-per-linter: 0
+  max-same-issues: 0
+
+linters:
+  disable:
+    - errcheck
+    - gocritic
+    - unused
+  settings:
+    errcheck:
+      check-type-assertions: true
+      disable-default-exclusions: true
+    gocritic:
+      enable-all: true

atproto/identity/apidir/apidir.go

···
 	DID syntax.DID `json:"did"`
 }
 
-type errorBody struct {
-	Name    string `json:"error"`
-	Message string `json:"message,omitempty"`
-}
-
 func NewAPIDirectory(host string) APIDirectory {
 	return APIDirectory{
 		Client: &http.Client{

atproto/identity/directory.go

···
 var ErrKeyNotDeclared = errors.New("DID document did not declare a relevant public key")
 
 // Handle was invalid, in a situation where a valid handle is required.
-var ErrInvalidHandle = errors.New("Invalid Handle")
+var ErrInvalidHandle = errors.New("invalid handle")
 
 var DefaultPLCURL = "https://plc.directory"
 

atproto/lexicon/cmd/lextool/net.go

···
 	}
 
 	body, err := data.UnmarshalJSON(respBytes)
+	if err != nil {
+		return err
+	}
 	record, ok := body["value"].(map[string]any)
 	if !ok {
 		return fmt.Errorf("fetched record was not an object")

atproto/repo/mst/mst_interop_test.go

···
 }
 
 func TestInteropKnownMapsTricky(t *testing.T) {
+	t.Skip("TODO: these are currently disallowed in typescript implementation")
 	assert := assert.New(t)
-
-	t.Skip("TODO: these are currently disallowed in typescript implementation")
 
 	cid1str := "bafyreie5cvv4h45feadgeuwhbcutmh6t2ceseocckahdoe6uat64zmz454"
 

atproto/repo/mst/mst_test.go

···
 
 	mapKeys := make([]string, len(inMap))
 	i := 0
-	for k, _ := range inMap {
+	for k := range inMap {
 		mapKeys[i] = k
 		i++
 	}

atproto/repo/mst/node.go

···
 		// TODO: should we actually return 0 in this case?
 		return 0, fmt.Errorf("can't determine key range of empty MST node")
 	}
-	if markDirty == true {
+	if markDirty {
 		n.Dirty = true
 	}
 	// check if lower than this entire node

atproto/repo/mst/node_insert.go

···
 package mst
 
 import (
+	"errors"
 	"fmt"
 	"slices"
 
···
 	}
 
 	// include "covering" proof for this operation
-	proveMutation(n, key)
+	if err := proveMutation(n, key); err != nil && !errors.Is(err, ErrPartialTree) {
+		return nil, nil, err
+	}
 
 	if !split {
 		// TODO: is this really necessary? or can we just slices.Insert beyond the end of a slice?

atproto/repo/mst/node_remove.go

···
 package mst
 
 import (
+	"errors"
 	"fmt"
 	"slices"
 
···
 	}
 
 	// marks adjacent child nodes dirty to include as "proof"
-	proveMutation(n, key)
+	if err := proveMutation(n, key); err != nil && !errors.Is(err, ErrPartialTree) {
+		return nil, nil, err
+	}
 
 	// check if top of node is now just a pointer
 	if top {

atproto/repo/operation.go

···
 
 	set := map[string]bool{}
 	for _, op := range list {
-		if _, ok := set[op.Path]; ok != false {
+		if _, ok := set[op.Path]; ok {
 			return nil, fmt.Errorf("duplicate path in operation list")
 		}
 		set[op.Path] = true

atproto/repo/operation_test.go

···
 	assert.NoError(err)
 	assert.Error(CheckOp(tree, op))
 
-	op, err = ApplyOp(tree, "color/pink", &c3)
+	_, err = ApplyOp(tree, "color/pink", &c3)
 	assert.NoError(err)
 	op, err = ApplyOp(tree, "color/pink", &c2)
+	assert.NoError(err)
 	assert.NoError(CheckOp(tree, op))
 	assert.True(op.IsUpdate())
 	err = InvertOp(tree, op)
···
 	}
 	mapKeys := make([]string, len(startMap))
 	i := 0
-	for k, _ := range startMap {
+	for k := range startMap {
 		mapKeys[i] = k
 		i++
 	}

atproto/syntax/did.go

···
 type DID string
 
 var didRegex = regexp.MustCompile(`^did:[a-z]+:[a-zA-Z0-9._:%-]*[a-zA-Z0-9._-]$`)
-var plcChars = ""
 
 func isASCIIAlphaNum(c rune) bool {
 	if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') {

atproto/syntax/tid.go

···
 
 // Constructs a new TID from a UNIX timestamp (in milliseconds) and clock ID value.
 func NewTID(unixMicros int64, clockId uint) TID {
-	var v uint64 = (uint64(unixMicros&0x1F_FFFF_FFFF_FFFF) << 10) | uint64(clockId&0x3FF)
+	v := (uint64(unixMicros&0x1F_FFFF_FFFF_FFFF) << 10) | uint64(clockId&0x3FF)
 	return NewTIDFromInteger(v)
 }