harvard-phd: EigenTrust plugin with checkable invariants

Description

The pitch.

## Which piece

**Trust layer.** Adds `eigentrust` as a bundled alternative to the
default `score_average` plugin, registered under
`(trust, eigentrust)` in `nest_core.plugins`.

## Why

The trust layer is the most interesting "what could go wrong"
surface in NEST: the bundled `score_average` is a running mean with
no Sybil resistance, no transitivity, no decay. The docs even point
to EigenTrust as "a good fit to test here". This PR delivers it —
not as an academic curiosity, but as a plugin whose correctness
properties are *asserted in tests*, not promised in comments.

## Core idea

EigenTrust (Kamvar, Schlosser, Garcia-Molina, WWW 2003) computes the
global trust vector as the stationary distribution of a teleporting
random walk over the local-trust graph:

```
t = (1 - alpha) * C^T * t + alpha * p
```

where

* `C` is the row-normalized local-trust matrix
  (`c_ij = max(0, pos_ij - neg_ij) / row_sum`, fallback to `p` when
  a row sums to zero — the "naive walker"), and
* `p` is the seed distribution over pre-trusted peers (uniform
  fallback when no pre-trusted set is declared).

Solved by power iteration; pure Python, no numpy dependency, in
line with the rest of the reference plugin pack.

## What's checkable, not just commented

The whole point of doing this in a verification-flavored way: every
property the algorithm claims is asserted in `test_eigentrust.py`.

| Property | Where it's enforced |
|---|---|
| Simplex (`sum_i t_i == 1`, `t_i >= 0`) | `_assert_on_simplex`, hand-rolled + hypothesis |
| Row-stochasticity of `C` | `_assert_row_stochastic`, hand-rolled + hypothesis |
| Fixed-point residual `< tol` | `_assert_fixed_point`, hand-rolled + hypothesis |
| Sybil upper bound `t_sybil <= alpha * p_sybil` | `test_sybil_lower_bound` |
| Weak monotonicity in honest positive evidence | `test_weak_monotonicity_of_positive_evidence` |
| `alpha = 1` recovers `p` exactly | `test_alpha_one_recovers_pretrusted_distribution` |
| Pre-trusted mass lower bound `t_i >= alpha * p_i` | property-based |

Hypothesis is already a dev dependency, so the property tests cost
nothing to add.

## How to test

```bash
# from the repo root, with the dev venv active
pip install -e packages/nest-core -e packages/nest-sdk -e packages/nest-plugins-reference
pip install pytest pytest-asyncio hypothesis

pytest packages/nest-plugins-reference/tests/test_eigentrust.py -v
# 16 tests, ~0.6s
```

Or wire it into a scenario:

```yaml
# scenarios/reputation.yaml
layers:
  trust: eigentrust
```

The plugin is drop-in compatible with the existing `Trust` protocol,
so no scenario YAML changes are required to test it under the
`reputation` scenario or anywhere else.

## Key assumptions

* **Threat model.** The plugin records reports under the reporter's
  identity (the `Evidence.reporter` field). A Sybil cannot forge an
  honest agent's report; if NEST's auth/identity layers fail upstream,
  no trust layer can save you.
* **Pre-trusted set is optional.** If you don't pass one, `p` is
  uniform and the Sybil-resistance bound degrades to the uniform
  case. The test for the Sybil upper bound makes this explicit by
  passing `pretrusted=[a0]`.
* **No self-trust.** Diagonal entries `c_ii` are forced to zero so
  agents can't short-circuit the random walk by endorsing
  themselves.
* **Pure Python.** Deliberately no numpy: keeps the reference pack
  free of heavy deps. Power iteration runs in `O(iters * |E|)` over
  the local-trust graph; with `DEFAULT_MAX_ITER=300` (sized for
  `(1 - alpha)^k < tol`) and the agent counts NEST actually
  simulates, this is sub-millisecond.

## Persona

Harvard CS PhD candidate in formal methods — invariants beat
comments; a property you can check beats a promise that one holds.

## Future work

* A `validate_reputation_sybil_bound` validator that reads a trace
  and asserts the Sybil upper bound directly, on top of the existing
  `reputation_scoring` / `reputation_warnings` checks.
* Time-decayed local trust (sliding window over evi

…