feat(core): initial implementation — launcher, logz, xerrors, valid

Introduces `code.nochebuena.dev/einherjar/core` — the foundational implementation
module of the Einherjar framework. Provides four sub-packages that together cover
every service's baseline needs: lifecycle management, structured logging, typed
errors, and struct validation.

- launcher: Launcher interface — three-phase managed lifecycle (OnInit → BeforeStart
  hooks → OnStart → OS signal wait → OnStop in reverse). Accepts
  lifecycle.Component and logging.Logger from contracts. Prints an ASCII art banner
  at startup (EINHERJAR_BANNER=off to suppress). Banner includes core version via
  runtime/debug.ReadBuildInfo() and a loaded-module list for every registered
  component that implements observability.Identifiable. Config struct with
  EINHERJAR_COMPONENT_STOP_TIMEOUT env tag (caarlos0/env syntax, default 15s).

- logz: Logger implementation backed by log/slog. Returns contracts/logging.Logger.
  Detects errs.CodedError and errs.ContextualError (from contracts/errs) to enrich
  log records automatically — replaces the private duck-typed bridge from micro-lib.
  Context helpers: WithRequestID, WithField, WithFields, GetRequestID. Config struct
  with EINHERJAR_LOG_LEVEL (default INFO) and EINHERJAR_LOG_JSON (default false) env
  tags (caarlos0/env syntax); programmatic-only fields StaticArgs and Writer carry no
  tags.

- xerrors: Typed error codes with context enrichment. Complete gRPC canonical set
  (16 codes) plus HTTP 410 ErrGone. Adds ErrOutOfRange, ErrAborted, ErrDataLoss
  over micro-lib. One convenience constructor per code. *Err declares compile-time
  satisfaction of errs.CodedError and errs.ContextualError.

- valid: Struct validation wrapping go-playground/validator/v10. Validator interface
  + MessageProvider interface with full built-in tag coverage (~150 tags) in both
  DefaultMessages (English) and SpanishMessages (Spanish). Backend fully hidden;
  returns *xerrors.Err with ErrInvalidInput or ErrInternal. FieldLevel interface
  abstracts the backend's field-level access for custom validators.
  WithCustomValidator registers custom validation tags at construction time;
  OverrideProvider chains a tag→handler map with a fallback MessageProvider for
  custom tag messages without re-implementing built-ins.

Compliance test enforces CT-6 (at most one exported TypeSpec per file via AST) and
verifies behavioural correctness of all four sub-packages, including custom validator
registration and OverrideProvider composition. Compile-time var _ assertions prove
interface satisfaction.

docs: ADR-001 (core module composition), ADR-002 (logz contracts/errs adoption),
ADR-003 (Config naming convention and caarlos0/env tag standard)

valid/validator.go

@@ -0,0 +1,85 @@
+package valid
+
+import (
+	"errors"
+	"reflect"
+	"strings"
+
+	"code.nochebuena.dev/einherjar/core/xerrors"
+	playground "github.com/go-playground/validator/v10"
+)
+
+// Validator validates structs using struct tags.
+type Validator interface {
+	// Struct validates v and returns a *xerrors.Err if validation fails.
+	// Returns nil if v is valid.
+	// Returns ErrInvalidInput for field constraint failures (first error only).
+	// Returns ErrInternal if v is not a struct.
+	Struct(v any) error
+}
+
+var _ Validator = (*validator)(nil)
+
+// New returns a Validator. Without options, DefaultMessages (English) is used.
+// Field names in error context use the json struct tag when available,
+// falling back to the Go field name.
+func New(opts ...Option) Validator {
+	cfg := &config{mp: DefaultMessages}
+	for _, o := range opts {
+		o(cfg)
+	}
+	v := playground.New()
+	v.RegisterTagNameFunc(func(fld reflect.StructField) string {
+		name := strings.SplitN(fld.Tag.Get("json"), ",", 2)[0]
+		if name == "" || name == "-" {
+			return fld.Name
+		}
+		return name
+	})
+	for _, cv := range cfg.customValidators {
+		if err := v.RegisterValidation(cv.tag, func(fl playground.FieldLevel) bool {
+			return cv.fn(fieldLevelAdapter{fl})
+		}); err != nil {
+			panic("valid: WithCustomValidator tag " + cv.tag + ": " + err.Error())
+		}
+	}
+	return &validator{v: v, mp: cfg.mp}
+}
+
+type fieldLevelAdapter struct{ fl playground.FieldLevel }
+
+func (a fieldLevelAdapter) Field() reflect.Value { return a.fl.Field() }
+func (a fieldLevelAdapter) Param() string        { return a.fl.Param() }
+func (a fieldLevelAdapter) FieldName() string    { return a.fl.FieldName() }
+
+type validator struct {
+	v  *playground.Validate
+	mp MessageProvider
+}
+
+// Struct implements Validator.
+// Only the first validation error is surfaced. Apps needing all failures can
+// cast errors.Unwrap(err) to playground.ValidationErrors themselves.
+func (val *validator) Struct(v any) error {
+	err := val.v.Struct(v)
+	if err == nil {
+		return nil
+	}
+
+	var invalidErr *playground.InvalidValidationError
+	if errors.As(err, &invalidErr) {
+		return xerrors.Wrap(xerrors.ErrInternal, "internal validation error", err)
+	}
+
+	var validationErrs playground.ValidationErrors
+	if errors.As(err, &validationErrs) {
+		first := validationErrs[0]
+		msg := val.mp.Message(first.Field(), first.Tag(), first.Param())
+		return xerrors.New(xerrors.ErrInvalidInput, msg).
+			WithContext("field", first.Field()).
+			WithContext("tag", first.Tag()).
+			WithError(err)
+	}
+
+	return xerrors.Wrap(xerrors.ErrInternal, "internal validation error", err)
+}