chore: add abstraction for worker operations

[matthewmcneely]

Description

This PR introduces a pluggable hooks framework that abstracts Zero-related operations in the worker package, enabling Dgraph to run in embedded mode without a separate Zero process -- many "unit" tests that aren't reliant on a full networked cluster would be great candidates for the abstraction.

Motivation

To support embedded deployment scenarios where Dgraph runs as a library within another application or in testing, the tight coupling between the worker package and Zero network operations needed to be abstracted. This allows alternative implementations to provide UID assignment, timestamp allocation, and transaction coordination without requiring a running Zero cluster.

Changes

New Package: hooks/

File	Description
hooks/config.go	Defines ZeroHooks interface and configuration management
hooks/init.go	Package documentation
hooks/config_test.go	Comprehensive unit tests with race detection

Testing

• 8 unit tests with -race flag covering:
  • Enable/Disable lifecycle
  • Custom vs default hooks precedence
  • Panic on missing configuration
  • ZeroHooksFns wrapper delegation
  • Concurrent access safety

Checklist

• The PR title follows the
  Conventional Commits syntax, leading
  with fix:, feat:, chore:, ci:, etc.
• Code compiles correctly and linting (via trunk) passes locally
• Tests added for new functionality, or regression tests for bug fixes added as applicable

[matthewmcneely]

Here's an example implementation that would work for an internal testing harness.

	// Enable embedded mode with Zero hooks to bypass distributed Zero node
	hooks.Enable(&hooks.Config{
		ZeroHooks: hooks.ZeroHooksFns{
			AssignUIDsFn: func(ctx context.Context, num *pb.Num) (*pb.AssignedIds, error) {
				num.Type = pb.Num_UID
				return engine.z.nextUIDs(num)
			},
			AssignTimestampsFn: func(ctx context.Context, num *pb.Num) (*pb.AssignedIds, error) {
				ts, err := engine.z.nextTs()
				if err != nil {
					return nil, err
				}
				return &pb.AssignedIds{StartId: ts, EndId: ts}, nil
			},
			AssignNsIDsFn: func(ctx context.Context, num *pb.Num) (*pb.AssignedIds, error) {
				num.Type = pb.Num_NS_ID
				nsID, err := engine.z.nextNamespace()
				if err != nil {
					return nil, err
				}
				return &pb.AssignedIds{StartId: nsID, EndId: nsID}, nil
			},
			CommitOrAbortFn: func(ctx context.Context, tc *api.TxnContext) (*api.TxnContext, error) {
				if tc.Aborted {
					return &api.TxnContext{StartTs: tc.StartTs, Aborted: true}, nil
				}
				commitTs, err := engine.z.nextTs()
				if err != nil {
					return nil, err
				}
				// Apply the commit to the oracle
				delta := &pb.OracleDelta{
					Txns: []*pb.TxnStatus{{StartTs: tc.StartTs, CommitTs: commitTs}},
				}
				posting.Oracle().ProcessDelta(delta)
				return &api.TxnContext{StartTs: tc.StartTs, CommitTs: commitTs}, nil
			},
			ApplyMutationsFn: func(ctx context.Context, m *pb.Mutations) (*api.TxnContext, error) {
				// Create a proposal with the mutations
				p := &pb.Proposal{Mutations: m}
				err := worker.ApplyMutations(ctx, p)
				return &api.TxnContext{StartTs: m.StartTs}, err
			},
		},
	})

Then one could directly access worker methods for queries and mutations, like

(&edgraph.Server{}).QueryNoAuth(ctx, &api.Request{...}})