Measure the explorer, and cap edit mode at what it can carry

Three numbers, taken on the emulator through the app's own render report
and written into EXPLORER.md; the fixture tree the sandbox now builds is
what they were taken against.

The viewer's scan was on the main thread. Decision 8 said off it, and the
first version did it in a `remember` inside the composition, which is not
that -- 460ms of frozen screen on a 1 MiB file, long enough that the
accessibility tree cannot be read, which is exactly what "the app has
stopped" looks like from outside. It runs on Dispatchers.Default now, with
a spinner where the file will be. Reading a megabyte is otherwise fine:
the viewer is a row per line, and it opens and scrolls 28,660 of them.

Edit mode needed a cap, and not the one the plan expected. The cost that
matters is not the highlighting -- 40ms a keystroke at 128 kB, which is
survivable -- it is Compose laying out one enormous text in the field:
2,027ms per frame at 128 kB, with typed characters dropped, and no
response at all at 1 MiB. Switching highlighting off would have saved
nothing, since every arrangement of a single text field pays it. So
EDIT_LIMIT is 32 kB, the largest size actually measured as usable, and
above it the pencil is disabled with the reason in words beside it: a
disabled control teaches what the thing can do but cannot say why it is
off, and a reader who cannot edit a file they can plainly read would
otherwise conclude the app is broken.

`FileLines.of` is timed like everything else here, so the figure lands in
the render report rather than needing a harness to ask for it.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

app/androidApp/src/main/kotlin/com/example/aiapp/FileLines.kt

@@ -56,13 +56,18 @@ private constructor(
          * file is one empty line numbered 1, which is what it is: a file with nothing in it still
          * has somewhere for a cursor to go.
          */
-        fun of(text: String, language: Language?): FileLines {
-            val body = text.removeSuffix("\n")
-            val lines = body.split('\n')
-            val rules = language?.let { rulesOf(it) }
-            val scanned = if (rules == null) emptyList() else scan(body, rules)
-            return FileLines(lines, bucket(lines, scanned))
-        }
+        fun of(text: String, language: Language?): FileLines =
+            // Timed, and always, for the same reason everything else here is: the cost of opening
+            // a large file is the number that decides whether the server's size limit is right,
+            // and an instrument that is only in the build nobody is running answers nothing. It
+            // lands in the render report beside the transcript's own figures.
+            DebugStats.timed("file scanned and cut into lines") {
+                val body = text.removeSuffix("\n")
+                val lines = body.split('\n')
+                val rules = language?.let { rulesOf(it) }
+                val scanned = if (rules == null) emptyList() else scan(body, rules)
+                FileLines(lines, bucket(lines, scanned))
+            }
 
         /**
          * The scanner's spans, in file offsets, as spans per line in line offsets.