identity: ensure handles are normalized in more places

atproto/identity/apidir/apidir.go

···
 }
 
 func (dir *APIDirectory) ResolveHandle(ctx context.Context, handle syntax.Handle) (syntax.DID, error) {
+	handle = handle.Normalize()
 	var body handleBody
 	u := dir.Host + "/xrpc/com.atproto.identity.resolveHandle?handle=" + handle.String()
 

atproto/identity/base_directory.go

···
 	if err != nil {
 		return nil, fmt.Errorf("could not verify handle/DID match: %w", err)
 	}
+	// NOTE: DeclaredHandle() returns a normalized handle, and we already normalized 'h' above
 	if declared != h {
 		return nil, fmt.Errorf("%w: %s != %s", ErrHandleMismatch, declared, h)
 	}

atproto/identity/cache_directory.go

···
 }
 
 func (d *CacheDirectory) ResolveHandle(ctx context.Context, h syntax.Handle) (syntax.DID, error) {
+	h = h.Normalize()
 	if h.IsInvalidHandle() {
 		return "", fmt.Errorf("can not resolve handle: %w", ErrInvalidHandle)
 	}
···
 	if err != nil {
 		return nil, hit, fmt.Errorf("could not verify handle/DID mapping: %w", err)
 	}
+	// NOTE: DeclaredHandle() returns a normalized handle, and we already normalized 'h' above
 	if declared != h {
 		return nil, hit, fmt.Errorf("%w: %s != %s", ErrHandleMismatch, declared, h)
 	}

atproto/identity/handle.go

···
 	var dnsErr error
 	var did syntax.DID
 
+	handle = handle.Normalize()
+
 	if handle.IsInvalidHandle() {
 		return "", fmt.Errorf("can not resolve handle: %w", ErrInvalidHandle)
 	}

atproto/identity/mock_directory.go

···
 
 func (d *MockDirectory) Insert(ident Identity) {
 	if !ident.Handle.IsInvalidHandle() {
-		d.Handles[ident.Handle] = ident.DID
+		d.Handles[ident.Handle.Normalize()] = ident.DID
 	}
 	d.Identities[ident.DID] = ident
 }

atproto/identity/mock_directory_test.go

···
 
 	_, err = c.ResolveDID(ctx, syntax.DID("did:plc:abc999"))
 	assert.ErrorIs(err, ErrDIDNotFound)
+
+	// handle lookups should be case-insensitive
+	_, err = c.ResolveHandle(ctx, syntax.Handle("handle.EXAMPLE.com"))
+	assert.NoError(err)
+	assert.Equal(id1.DID, did)
 }

atproto/identity/redisdir/redis_directory.go

···
 
 func (d *RedisDirectory) ResolveHandle(ctx context.Context, h syntax.Handle) (syntax.DID, error) {
 	start := time.Now()
+	h = h.Normalize()
 	if h.IsInvalidHandle() {
 		return "", fmt.Errorf("can not resolve handle: %w", identity.ErrInvalidHandle)
 	}
···
 	if err != nil {
 		return nil, hit, err
 	}
+	// NOTE: DeclaredHandle() returns a normalized handle, and we already normalized 'h' above
 	if declared != h {
 		return nil, hit, identity.ErrHandleMismatch
 	}