It doesn't seem this example demonstrated anything useful 🤔

It demonstrates accessing a non-sharable instance variable in a module or class raises an exception.

Oh, but now I see how this example is useful :) The difference with the previous one is exactly in passing the class vs accessing it as a constant :)

This example doesn't do a good job of showing how this behavior is specific to modules and classes. The same type example works for instances:

     class C
         attr_accessor :tricky
     end

     c = C.new
     c.tricky = ['test'.freeze].freeze

     r = Ractor.new(c) do |cls|
       puts "I see #{cls}"
       puts "I see #{cls.tricky}"
     end
     r.take

The same type of example also works for unsharable values for instances:

     class C
         attr_accessor :tricky
     end

     c = C.new
     c.tricky = ['test'.freeze]

     r = Ractor.new(c) do |c2|
       puts "I see #{c2}"
       puts "I see #{c2.tricky}"
     end
     r.take

In most cases, you aren't going to be passing modules and classes to the ractor, but having the ractor access them directly. Here is an example that shows that such access is allowed for sharable values:

     class C
       class << self
         attr_accessor :tricky
       end
     end

     C.tricky = ['test'.freeze].freeze

     r = Ractor.new do
       puts "I see #{C}"
       puts "I see #{C.tricky}"
     end
     r.take

Here's an example that shows failure for none sharable values:

     class C
       class << self
         attr_accessor :tricky
       end
     end

     C.tricky = ['test'.freeze]

     r = Ractor.new do
       puts "I see #{C}"
       puts "I see #{C.tricky}"
     end
     r.take

This example doesn't do a good job of showing how this behavior is specific to modules and classes.

Actually, it seems to be: the "(especially modules and classes)" part is important.

Here's an example that shows failure for non sharable values:

It wouldn't fail if you'll try it:

class C
  attr_accessor :tricky
end

c = C.new
c.tricky = ['test']

r = Ractor.new(c) do |c2|
  puts "I see #{c2}" # I see #<C:0x00007f46d4dc80d0>
  puts "I see #{c2.tricky}"
end
r.take
p c # #<C:0x00007f46d4dc8620 @tricky=["test"]>

Note that object ids of c and c2 are different. As far as I understand, it just copies c into c2 and it becomes fully accessible inside Ractor, but unrelated to c.
It's because Ractor.shareable?(c) is false, and the documentation describes the behavior of mutable shareable objects.

The behavior that changed in 3.1 is related specifically to module/class instance vars, as far as I understand. Your example works both on 3.0 and 3.1, while this one:

class C
  class << self
    attr_accessor :tricky
  end
end

C.tricky = ['test'.freeze].freeze

r = Ractor.new(C) do |cls|
  puts "I see #{cls}"
  puts "I see #{cls.tricky}"
end
r.take

...will work on 3.1, but on 3.0, it throws "can not access instance variables of classes/modules from non-main Ractor".

(Edited the examples, sorry, didn't get it right the first time)

It demonstrates accessing a non-sharable instance variable in a module or class raises an exception.