Require explicit extern members in extern class/object and update docs

docs/embedding.md

@@ -243,6 +243,12 @@ For extensions and libraries, the **preferred** workflow is Lyng‑first: declar
 
 This keeps Lyng semantics (visibility, overrides, type checks) in Lyng, while Kotlin supplies the behavior.
 
+Pure extern declarations use the simplified rule set:
+- `extern class` / `extern object` are declaration-only ABI surfaces.
+- Every member in their body must be explicitly marked `extern`.
+- Plain Lyng member implementations inside `extern class` / `extern object` are not allowed.
+- Put Lyng behavior into regular classes or extension methods.
+
 ```lyng
 // Lyng side (in a module)
 class Counter {
@@ -253,6 +259,21 @@ class Counter {
 
 Note: members must be marked `extern` so the compiler emits the ABI slots that Kotlin bindings attach to. This applies to functions and properties bound via `addFun` / `addVal` / `addVar`.
 
+Example of pure extern class declaration:
+
+```lyng
+extern class HostCounter {
+    extern var value: Int
+    extern fun inc(by: Int): Int
+}
+```
+
+If you need Lyng-side convenience behavior, add it as an extension:
+
+```lyng
+fun HostCounter.bump() = inc(1)
+```
+
 ```kotlin
 // Kotlin side (binding)
 val moduleScope = Script.newScope() // or an existing module scope

docs/whats_new.md

@@ -249,5 +249,6 @@ Lyng now provides a public Kotlin reflection bridge and a Lyng‑first class bin
 
 - **Bridge resolver**: explicit handles for values, vars, and callables with predictable lookup rules.
 - **Class bridge binding**: declare classes/members in Lyng (marked `extern`) and bind the implementations in Kotlin before the first instance is created.
+- **Extern declaration rule**: `extern class` / `extern object` are declaration-only; all members in their bodies must be explicitly marked `extern`.
 
 See **Embedding Lyng** for full samples and usage details.

docs/whats_new_1_5.md

@@ -18,6 +18,11 @@ In particular, it means no slow and flaky runtime lookups. Once compiled, code g
 
 The API is fixed and will be kept with further Lyng core changes. It is now the recommended way to write Lyng extensions in Kotlin. It is much simpler and more elegant than the internal one. See [Kotlin Bridge Binding](../notes/kotlin_bridge_binding.md).
 
+Extern declaration clarification:
+- `extern class` / `extern object` are pure extern surfaces.
+- Members inside them must be explicitly marked `extern`.
+- Lyng method/property bodies for these declarations should be implemented as extensions instead.
+
 ### Smart types system
 
 - **Deep inference**: The compiler analyzes types of symbols along the execution path and in many cases eliminates unnecessary casts or type specifications.