Make dim-si types easy to use for end users

[dyreby]

Users of dim-si shouldn't need to reach into lower-level packages (dim-quantity, dim-unit) to annotate their functions. The key types for function signatures are Linear and Affine (from dim-unit), which express whether a parameter is a regular quantity or an affine one (like absolute temperature).

Approach:

• Re-export Linear and Affine from @isentropic/dim-si root module
• Document Linear for standard quantity annotations (e.g., Linear<Length>, Linear<Velocity>)
• Document Affine for affine quantities (e.g., Affine<Temperature>)
• Update README prose to explain Linear vs Affine instead of referencing Quantity

Example of what end-user code should look like:

import type { Linear } from "@isentropic/dim-si";
import type { Length } from "@isentropic/dim-si/length";
import type { Time } from "@isentropic/dim-si/time";
import type { Velocity } from "@isentropic/dim-si/velocity";
import { divide } from "@isentropic/dim-si/ops";

function speed(
  distance: Linear<Length>,
  duration: Linear<Time>,
): Linear<Velocity> {
  return divide(distance, duration);
}

import type { Affine } from "@isentropic/dim-si";
import type { Temperature } from "@isentropic/dim-si/temperature";
import { kelvin } from "@isentropic/dim-si/temperature";
import { q } from "@isentropic/dim-si/ops";

function toKelvin(temp: Affine<Temperature>): number {
  return q(temp).in(kelvin);
}

[gdtroszak]

After some thought, here's the revised plan:

Problem: The issue originally proposed re-exporting Linear and Affine from dim-si for use in function signatures. But there's a footgun — nothing prevents Affine<Length>, which is semantically meaningless in SI. The type system won't catch it.

Solution: Export concrete quantity types from each module instead. Users get purpose-built annotation types and never need to touch Linear or Affine directly.

Changes:

1. Stop re-exporting dimension types from dim-isq (e.g., export type { Length } from "@isentropic/dim-isq" goes away)
2. Replace with quantity type aliases:
   • type Length = Linear<LengthDim, Si> in each quantity module
   • type Temperature = Affine<TemperatureDim, Si> and type TemperatureDifference = Linear<TemperatureDim, Si> for temperature
3. Do not re-export Linear or Affine from dim-si — users shouldn't need them
4. Ops signatures unchanged — they keep working generically over Linear<D, S> and Affine<D, S>; the new types are assignable to/from those
5. Update README and docs to show the new pattern

Usage:

import type { Length } from "@isentropic/dim-si/length";
import type { Time } from "@isentropic/dim-si/time";
import type { Velocity } from "@isentropic/dim-si/velocity";
import { divide } from "@isentropic/dim-si/ops";

function speed(d: Length, t: Time): Velocity {
  return divide(d, t);
}

import type { Temperature, TemperatureDifference } from "@isentropic/dim-si/temperature";

function convertToF(temp: Temperature): Temperature { ... }
function averageDelta(a: TemperatureDifference, b: TemperatureDifference): TemperatureDifference { ... }

Breaking change: Length, Temperature, etc. imported from dim-si will change from dimension types to quantity types. This is acceptable given project maturity.