Add hexadecimal literals for Byte

[jiribenes]

Format: '0x' <hexa> <hexa> where <hexa> ::= 0 | 1 | ... | a | A | b | B | ... | f | F.
Note that it's only for bytes, i.e. values between 0x00 (0) and 0xFF (255) that have the Byte type, everything else should fail.
Specifically, this notation is not for integers of type Int, it's just for us being able to write 0xEF directly instead of relying on 239.toByte.

[jiribenes]

I'm setting this as a good first issue, so here's a walkthrough.
Note that it might be better to split this up into a few PRs :)

1. Go to the Lexer, and add a new TokenKind for Byte literals

   effekt/effekt/shared/src/main/scala/effekt/Lexer.scala

   Lines 25 to 30 in f4c840f

   	enum TokenKind {
   	// literals
   	case Integer(n: Long)
   	case Float(d: Double)
   	case Str(s: String, multiline: Boolean)
   	case Chr(c: Int)

   ,
2. then search for where we parse the Integer TokenKind and adapt the code. Also take a look at the existing hexadecimal declaration corresponding to <hexa> above in the grammar ,
3. then add a corresponding test to LexerTests https://github.com/effekt-lang/effekt/blob/f4c840f3f4d6047410b5897bbd30fb4bdce61360/effekt/jvm/src/test/scala/effekt/LexerTests.scala .
4. Define a Byte literal in the Source.Tree:

   effekt/effekt/shared/src/main/scala/effekt/source/Tree.scala

   Lines 407 to 414 in f4c840f

   	// Smart Constructors for literals
   	// -------------------------------
   	def UnitLit(): Literal = Literal((), symbols.builtins.TUnit)
   	def IntLit(value: Long): Literal = Literal(value, symbols.builtins.TInt)
   	def BooleanLit(value: Boolean): Literal = Literal(value, symbols.builtins.TBoolean)
   	def DoubleLit(value: Double): Literal = Literal(value, symbols.builtins.TDouble)
   	def StringLit(value: String): Literal = Literal(value, symbols.builtins.TString)
   	def CharLit(value: Int): Literal = Literal(value, symbols.builtins.TChar)

   ,
5. then parse it in the parser:

   effekt/effekt/shared/src/main/scala/effekt/RecursiveDescent.scala

   Lines 1051 to 1062 in f4c840f

   	def literal(): Literal =
   	nonterminal:
   	peek.kind match {
   	case Integer(v) => skip(); IntLit(v)
   	case Float(v) => skip(); DoubleLit(v)
   	case Str(s, multiline) => skip(); StringLit(s)
   	case Chr(c) => skip(); CharLit(c)
   	case `true` => skip(); BooleanLit(true)
   	case `false` => skip(); BooleanLit(false)
   	case t if isUnitLiteral => skip(); skip(); UnitLit()
   	case t => fail("Expected a literal")
   	}

   (don't forget to change isLiteral too!) ,
6. then add a corresponding test to RecursiveDescentTests

   effekt/effekt/jvm/src/test/scala/effekt/RecursiveDescentTests.scala

   Line 12 in f4c840f

   class RecursiveDescentTests extends munit.FunSuite {

   .
7. Compile the whole project, run the Effekt executable, try using 0x... and fixing the found bugs.
8. then a few examples into examples/pos to ensure it doesn't break again.
9. ideally, as a last step, try to make the lexer less brittle by it being able to parse (and discard) invalid expressions like 0x, 0xF, 0xFFFF, 0xabracadabra

[jiribenes]

Also, please remember to update the show instance for Byte to better reflect the new syntax:

effekt/libraries/common/effekt.effekt

Lines 91 to 98 in f4c840f

	extern pure def show(value: Byte): String =
	js "'' + ${value}"
	chez "(string ${value})"
	llvm """
	%z = call %Pos @c_bytearray_show_Byte(i8 ${value})
	ret %Pos %z
	"""
	vm "effekt::show(Byte)"