// Before — 'T silently inferred as obj if no context:
let row = frame.GetRow("key")              // Series<_, obj> — silent

// After — compile error if type omitted, forces intent:
let row = frame.GetRow(float)("key")       // ✅ explicit and safe
let row = frame.GetRow("key") : Series<_, float>  // ✅ annotation also works

// ObjectSeries — same story:
let col = os.GetAs(int)("Count")           // ✅ explicit  
let col = os.As(float)()                   // ✅ explicit
```

## Scope

Members annotated with `[(RequiresExplicitTypeArguments)]`:
- `Frame.GetRow<'T>` (both overloads)
- `Frame.TryGetRow<'T>` (both overloads)
- `Frame.TryGetRowObservation<'T>`
- `ObjectSeries.As<'R>`
- `ObjectSeries.TryAs<'R>` (both overloads)
- `ObjectSeries.GetAs<'R>` (both overloads)
- `ObjectSeries.TryGetAs<'R>` (both overloads)

**Not changed**: `GetColumn`, `TryGetColumn` and related column methods.
Columns typically have clearer type constraints from surrounding code, so the
benefit is smaller and the internal refactor costs would be higher.

## Internal call-site fixes

`FrameModule.fs` wrapper functions (`getRow`, `lookupRow`, `tryLookupRow`,
`tryLookupRowObservation`) are made `inline` so their `'T` parameter is
resolved at each call site, preserving full generic inference for the `'R` and
`'C` frame key types. No public API signatures change.

One test (`Frame.fs`) updated: `dfi.TryGetRow(2)` → `dfi.TryGetRow(obj)(2)`
to explicitly state the intent (checking row existence, not reading typed
values).

## Test Status

```
Passed!  - Failed: 0, Passed: 669, Skipped: 0, Total: 669