Fix LeakyParallel silently ignoring a per-neuron beta; correct the reset=zero formula in Leaky - #441

…set="zero" formula in Leaky

### Problem

**1. `LeakyParallel` drops a per-neuron `beta`.**
`_beta_to_weight_hh` walks an `if / elif / elif / else` chain:

    if isinstance(self.beta, (float, int)): ...
    elif isinstance(self.beta, torch.Tensor) or isinstance(self.beta, torch.FloatTensor):
        if len(self.beta) == 1: ...
    elif len(self.beta) == self.hidden_size:   # <-- sibling of the Tensor elif
        for i in range(self.hidden_size): ...
    else:
        raise ValueError(...)

`_beta_buffer` always stores `beta` as a `torch.Tensor`, so control always
enters the second branch and only its inner `if len(self.beta) == 1` is
reachable. The `elif len(self.beta) == self.hidden_size` (the per-neuron
path) and the `else: raise ValueError` are dead. Passing
`beta=<tensor of length hidden_size>` -- which the docstring explicitly
supports ("multi-valued (one weight per neuron)") -- leaves
`rnn.weight_hh_l0` at its random RNN initialization, with no error. The
layer then trains and runs with arbitrary recurrent decay rates instead
of the requested ones.

**2. `Leaky` docstring for `reset_mechanism="zero"` is wrong.**
It states `U[t+1] = βU[t] + I_syn[t+1] - R(βU[t] + I_in[t+1])`, i.e.
`(1-R)(βU[t] + I)`, which is `0` on the step after a spike regardless of
input. The implementation (`_base_zero`) is standard reset-then-integrate,
`U[t+1] = β(1-R)U[t] + I_in[t+1]`, which equals `I_in` on that step. Also
`Leaky` has no synaptic current, so `I_syn` is a copy-paste from
`Synaptic`.

### Changes

- `snntorch/_neurons/leakyparallel.py`: nest the two length checks (and
  the `ValueError`) inside the `torch.Tensor` branch so the per-neuron
  path is reached; a genuinely unsupported `beta` type now raises
  `TypeError` instead of falling through silently.
- `snntorch/_neurons/leaky.py`: fix the `reset_mechanism="zero"` formula
  and drop the stray `I_syn`.

### Tests

New `tests/test_snntorch/test_leakyparallel.py` (5 tests):

- scalar `beta` still fills the diagonal,
- **per-neuron `beta` (len == hidden_size) is written to the diagonal**
  (fails without this change),
- length-1 `beta` tensor still works,
- **a bad-length `beta` raises `ValueError`** (fails without this change --
  it was silently accepted),
- **two layers identical but for a per-neuron `beta` produce different
  outputs** (fails without this change -- both ran at the default
  recurrent weights).

Full suite: 195 -> 200 passed, 2 xfailed.