docs: convert README bullet lists to prose

Author: rasros

README.md

@@ -23,15 +23,12 @@ keys.
 
 ## Overview
 
-KEncode provides three standalone entry points:
-
-1. **ByteEncoding** text codecs: Base62, Base36, Base64, and Base85 encoders
-   for raw binary data.
-2. **PackedFormat**: A binary format serializer that supports nested objects,
-   lists, and maps. It uses bitsets for booleans and nullability to minimize
-   overhead.
-3. **EncodedFormat**: A string format serializer that wraps the above to produce
-   small deterministic string identifiers.
+KEncode has three standalone entry points. ByteEncoding is a set of text codecs
+(Base62, Base36, Base64, Base85) for raw binary data. PackedFormat is a
+kotlinx.serialization BinaryFormat that produces compact byte payloads for
+Kotlin classes, including nested objects, lists, and maps. EncodedFormat layers
+a text codec and optional payload transforms over a binary format to produce
+short, deterministic string identifiers.
 
 For a walkthrough of the bit-packing layout and design choices, see the
 [technical deep dive](https://eignex.com/posts/kencode-packing-data-for-strict-limits/).
@@ -74,16 +71,13 @@ val decoded = EncodedFormat.decodeFromString<Payload>(encoded)
 
 ## PackedFormat
 
-PackedFormat is a `BinaryFormat` for Kotlin classes that emits compact byte
-payloads.
-
-* Bit-Packing: Booleans and nullability markers share a single bit-header
-  (~1 bit per field).
-* VarInts: annotate `Int`/`Long` fields with `@PackedType(IntPacking.DEFAULT)`
-  (unsigned varint) or `@PackedType(IntPacking.SIGNED)` (ZigZag). `@ProtoType`
-  is recognized as a fallback.
-* Full Graph Support: nested objects, lists, maps, and polymorphism are
-  handled recursively.
+PackedFormat is a BinaryFormat for Kotlin classes that emits compact byte
+payloads. Booleans and nullability markers share a single bit-header (about one
+bit per field), and nested objects, lists, maps, and polymorphism are handled
+recursively. Int and Long fields can be annotated with
+`@PackedType(IntPacking.DEFAULT)` for unsigned varint or
+`@PackedType(IntPacking.SIGNED)` for ZigZag; `@ProtoType` is recognized as a
+fallback.
 
 ```kotlin
 val compactFormat = PackedFormat {
@@ -99,15 +93,14 @@ val bytes = compactFormat.encodeToByteArray(payload)
 
 ## EncodedFormat
 
-EncodedFormat provides a StringFormat API that produces short tokens by
-composing three layers:
-
-1. Binary Layer: PackedFormat (default) or ProtoBuf (recommended for
-   cross-language compatibility).
-2. Transform Layer: Optional `PayloadTransform` applied after serialization
-   (e.g. `CompactZeros`, `Checksum.asTransform()`, or a custom transform for
-   encryption or ECC). Chain transforms with `PayloadTransform.then`.
-3. Text Layer: Base62 (default), Base36, Base64, or Base85.
+EncodedFormat is a StringFormat that produces short tokens by composing three
+layers. The binary layer is PackedFormat by default, but ProtoBuf is a good
+choice when cross-language compatibility matters. After serialization, an
+optional PayloadTransform can manipulate the bytes — for example `CompactZeros`
+to strip leading zeros, `Checksum.asTransform()` to append an integrity check,
+or a custom transform for encryption or error correction; transforms compose
+with `PayloadTransform.then`. Finally a text codec turns the bytes into a
+string, with Base62 as the default and Base36, Base64, and Base85 available.
 
 ```kotlin
 val customFormat = EncodedFormat {
@@ -128,13 +121,11 @@ val withBoth = EncodedFormat {
 
 ## Base Encoders
 
-KEncode includes standalone codecs for byte-to-text conversion. All
-implementations support custom alphabets.
-
-* Base62 / Base36: fixed-block encoding with predictable lengths and no
-  padding; alpha-numeric output, with or without upper-case.
-* Base85: high-density encoding (4 bytes → 5 characters).
-* Base64 / Base64Url: RFC 4648 compatible.
+KEncode ships standalone byte-to-text codecs, all of which accept custom
+alphabets. Base62 and Base36 use fixed-block encoding for predictable lengths
+without padding, and produce purely alpha-numeric output (with or without
+upper-case). Base85 trades alphabet size for density, encoding four bytes into
+five characters. Base64 and Base64Url are RFC 4648 compatible.
 
 Encoding `"any byte data"` (13 bytes):