restructure: rsnix kernel + shell crate + rsdos entry point

Architecture:
  rs-dos/  (workspace root, was raisernics/)
  ├── rsnix/     — kernel lib crate (uefi, serial, gop, ps2, interrupts, memory)
  ├── shell/     — shell lib crate (prompt, commands, line input)
  ├── rsdos/     — binary crate (efi_main, init, panic handler)
  └── rsboot/    — future git submodule

No functional changes — boots to shell prompt identically.
Version auto-pulled from Cargo.toml via env!("CARGO_PKG_VERSION").

1 files changed, 26 insertions, 16 deletions

diff --git a/src/shell.rs b/shell/src/lib.rs
index 8e4cb62..bdd79c6 100644
--- a/src/shell.rs
+++ b/shell/src/lib.rs
@@ -1,14 +1,24 @@
+#![no_std]
+
+extern crate alloc;
+
 /// Minimal command shell — reads from PS/2 keyboard, writes to GOP + serial.
-use crate::ps2::{self, KeyEvent};
-use crate::{gop_print, gop_println, serial_print, serial_println};
+use rsnix::ps2::{self, KeyEvent};
+use rsnix::{gop_print, gop_println, serial_print, serial_println};
 
 /// Maximum input line length.
 const LINE_BUF_SIZE: usize = 256;
 
 /// Run the shell forever.
 pub fn run() -> ! {
-    gop_println!("raisernics v{} — type 'help' for commands", env!("CARGO_PKG_VERSION"));
-    serial_println!("========== raisernics v{} ==========", env!("CARGO_PKG_VERSION"));
+    gop_println!(
+        "rs-dos v{} — type 'help' for commands",
+        env!("CARGO_PKG_VERSION")
+    );
+    serial_println!(
+        "========== rs-dos v{} ==========",
+        env!("CARGO_PKG_VERSION")
+    );
 
     loop {
         // Print prompt
@@ -53,32 +63,32 @@ fn read_line() -> heapless_str::String<LINE_BUF_SIZE> {
     loop {
         match ps2::poll_key() {
             KeyEvent::Enter => {
-                crate::gop::put_char('\n');
-                crate::serial::write_str("\r\n");
+                rsnix::gop::put_char('\n');
+                rsnix::serial::write_str("\r\n");
                 return buf;
             }
             KeyEvent::Char(c) if c.is_ascii_graphic() || c == ' ' => {
                 if buf.push(c).is_ok() {
-                    crate::gop::put_char(c);
+                    rsnix::gop::put_char(c);
                     // Echo to serial too
                     let mut s = [0u8; 4];
                     let s = c.encode_utf8(&mut s);
-                    crate::serial::write_str(s);
+                    rsnix::serial::write_str(s);
                 }
             }
             KeyEvent::Backspace => {
                 if buf.pop().is_some() {
                     // GOP backspace: move cursor back and erase
-                    crate::gop::put_char('\x08');
+                    rsnix::gop::put_char('\x08');
                     // Serial backspace: send BS SP BS (standard terminal protocol)
-                    crate::serial::write_str("\x08 \x08");
+                    rsnix::serial::write_str("\x08 \x08");
                 }
             }
             KeyEvent::Tab => {
                 for _ in 0..4 {
                     if buf.push(' ').is_ok() {
-                        crate::gop::put_char(' ');
-                        crate::serial::write_str(" ");
+                        rsnix::gop::put_char(' ');
+                        rsnix::serial::write_str(" ");
                     }
                 }
             }
@@ -120,14 +130,14 @@ fn cmd_echo(args: &str) {
 }
 
 fn cmd_clear() {
-    crate::gop::clear_screen();
+    rsnix::gop::clear_screen();
 }
 
 fn cmd_info() {
     // Test that the global allocator works: build a String on the heap
-    let mut s = alloc::string::String::from("raisernics v");
+    let mut s = alloc::string::String::from("rs-dos v");
     s.push_str(env!("CARGO_PKG_VERSION"));
-    s.push_str(" — RNG custom kernel");
+    s.push_str(" — rsnix kernel");
     gop_println!("{}", s);
     gop_println!("arch: x86_64, freestanding, no userspace");
     serial_println!("{}", s);
@@ -136,7 +146,7 @@ fn cmd_info() {
 }
 
 fn cmd_mem() {
-    let (map, key) = crate::memory::get_map();
+    let (map, key) = rsnix::memory::get_map();
 
     let mut total_kb = 0u64;
     let mut conventional_kb = 0u64;